internal static IfThrowPrecondition TryCreate(ICSharpStatement statement) { Contract.Requires(statement != null); var ifStatement = statement as IIfStatement; if (ifStatement == null || ifStatement.Condition == null) return null; var predicateExpression = PredicateExpression.Create(ifStatement.Condition); IThrowStatement throwStatement = ParseThrowStatement(ifStatement); if (throwStatement == null) return null; var arguments = throwStatement.GetArguments().ToList(); var exceptionType = throwStatement.GetExceptionType(); if (exceptionType == null) return null; // We can deal with any exception derived from the ArgumentException if (!IsDerivedOrEqualFor(exceptionType, typeof(ArgumentException)) || arguments.Count == 0) { return null; } var message = arguments.Skip(1).FirstOrDefault() .Return(ExtractMessage, NoMessage.Instance); // message is optional and should be second argument return new IfThrowPrecondition(ifStatement, predicateExpression, message, exceptionType); }
private static bool IsContainingMethodAsync(ICSharpStatement statement) { return statement .GetContainingTypeMemberDeclaration() .With(x => x as ICSharpFunctionDeclaration) .ReturnStruct(x => x.IsAsync) == true; }
public void Eat(ISnapshot snapshot, ICSharpStatement statement) { if (statement == null) throw new ArgumentNullException("statement"); GetEater(statement).Eat(snapshot, statement); }
public DictionaryContainsKeyWarning(ICSharpStatement statement, ITreeNode[] dictionaryAccess, ITreeNode matchedElement, ITreeNode key, IExpression dictionary) { Statement = statement; MatchedElement = matchedElement; Dictionary = dictionary; Key = key; DictionaryAccess = dictionaryAccess; }
internal ContractEnsures(ICSharpStatement statement, PredicateExpression predicateExpression, Message message) : base(statement, predicateExpression, message) { _contractResultArgument = predicateExpression.Predicates.Select(p => p.Argument) .OfType<ContractResultPredicateArgument>() .FirstOrDefault(); }
public DictionaryContainsKeyFix(DictionaryContainsKeyWarning warning) { _statement = warning.Statement; _matchedElement = warning.MatchedElement; _dictionaryAccess = warning.DictionaryAccess; _dictionary = warning.Dictionary; _key = warning.Key; }
public RedundantRequiresCheckerHighlighting(ICSharpStatement preconditionStatement, string argumentName) { Contract.Requires(preconditionStatement != null); Contract.Requires(!string.IsNullOrEmpty(argumentName)); _preconditionStatement = preconditionStatement; _argumentName = argumentName; }
protected ContextActionExecutorBase(ICSharpStatement statement) { Contract.Requires(statement != null); _psiModule = statement.GetPsiModule(); _psiServices = statement.GetPsiServices(); _factory = CSharpElementFactory.GetInstance(statement); _currentFile = (ICSharpFile)statement.GetContainingFile(); }
public static ContractStatement TryCreate(ICSharpStatement statement) { Contract.Requires(statement != null); return _factoryMethods .Select(factory => factory(statement)) .FirstOrDefault(contract => contract != null); }
protected ContractStatement(ICSharpStatement statement, PredicateExpression predicateExpression, Message message) { Contract.Requires(statement != null); Contract.Requires(predicateExpression != null); Contract.Requires(message != null); _statement = statement; _predicateExpression = predicateExpression; _message = message; }
internal MalformedContractErrorHighlighting(ICSharpStatement statement, CodeContractStatement validatedStatement, ValidationResult validationResult) { Contract.Requires(validatedStatement != null); Contract.Requires(validationResult != null); _range = statement.GetHighlightingRange(); _validatedStatement = validatedStatement; _validationResult = validationResult; _toolTip = _validationResult.GetErrorText(); }
internal CodeContractWarningHighlighting(ICSharpStatement statement, CodeContractWarningValidationResult warning, ValidatedContractBlock contractBlock) { Contract.Requires(warning != null); Contract.Requires(contractBlock != null); Contract.Requires(statement != null); _warning = warning; _contractBlock = contractBlock; _range = statement.GetHighlightingRange(); _toolTip = warning.GetErrorText(); }
internal static ContractCustomWarningHighlighting Create(ICSharpStatement statement, CustomWarningValidationResult warning, ValidatedContractBlock contractBlock) { switch (warning.Warning) { case MalformedContractCustomWarning.PreconditionInAsyncMethod: case MalformedContractCustomWarning.PreconditionInMethodWithIteratorBlock: return null; default: return new ContractCustomWarningHighlighting(statement, warning, contractBlock); } }
public static ProcessedStatement Create(ICSharpStatement statement) { Contract.Requires(statement != null); Contract.Ensures(Contract.Result<ProcessedStatement>() != null); return new ProcessedStatement { CSharpStatement = statement, ContractStatement = ContractStatementFactory.TryCreate(statement), }; }
internal RequiresInconsistentVisibiityHighlighting(ICSharpStatement preconditionStatement, MemberWithAccess preconditionContainer, MemberWithAccess lessVisibleReferencedMember) { Contract.Requires(preconditionStatement != null); Contract.Requires(preconditionContainer != null); Contract.Requires(lessVisibleReferencedMember != null); _range = preconditionStatement.GetHighlightingRange(); _preconditionContainer = preconditionContainer; _lessVisibleReferencedMember = lessVisibleReferencedMember; }
private static void InsertDeclarations( [NotNull] IInvocationExpression invocation, ref LocalList <IDeclarationStatement> declarations) { IBlock block = invocation.GetContainingNode <IBlock>(true).NotNull(); ICSharpStatement anchor = invocation.GetContainingStatement(); for (var i = declarations.Count - 1; i >= 0; i--) { declarations[i] = block.AddStatementBefore(declarations[i], anchor); anchor = declarations[i]; } }
internal static ContractCustomWarningHighlighting Create(ICSharpStatement statement, CustomWarningValidationResult warning, ValidatedContractBlock contractBlock) { switch (warning.Warning) { case MalformedContractCustomWarning.PreconditionInAsyncMethod: case MalformedContractCustomWarning.PreconditionInMethodWithIteratorBlock: return(null); default: return(new ContractCustomWarningHighlighting(statement, warning, contractBlock)); } }
internal ContractCustomWarningHighlighting(ICSharpStatement statement, CustomWarningValidationResult warning, ValidatedContractBlock contractBlock) { Contract.Requires(warning != null); Contract.Requires(contractBlock != null); Contract.Assert(_range != null); _range = statement.GetHighlightingRange(); _toolTip = warning.GetErrorText(); _validationResult = warning; _contractBlock = contractBlock; MethodName = warning.GetEnclosingMethodName(); }
private bool IsFinalStatement([NotNull] ICSharpStatement statement) { while (statement.GetNextStatement() == null) { if (statement == null) { return(true); } statement = statement.GetContainingStatement(); } return(false); }
public static IPrecondition TryCreatePrecondition(ICSharpStatement statement) { var ifThrowPrecondition = IfThrowPrecondition.TryCreate(statement); if (ifThrowPrecondition != null) return ifThrowPrecondition; var requires = CodeContractAssertion.TryCreate(statement) as IPrecondition; if (requires != null) return requires; return null; }
public static IInvocationExpression AsInvocationExpression(ICSharpStatement statement) { var expressionStatement = statement as IExpressionStatement; if (expressionStatement == null) return null; var visitor = new InvocationVisitor(); expressionStatement.Expression.Accept(visitor); if (visitor.InvocationExpression == null) return null; return visitor.InvocationExpression; }
public IStatementEater GetEater(ICSharpStatement statement) { var eater = _container.GetInstance <IEnumerable <IStatementEater> >() .SingleOrDefault(t => t.StatementType.IsInstanceOfType(statement)); if (eater == null) { return(new StubStatementEater()); } return(eater); }
private bool IsFinallyBlock(IBlock block, ICSharpStatement parentStatement) { var tryBlock = parentStatement as ITryStatement; if (tryBlock != null) { if (tryBlock.FinallyBlock == block) { return(true); } } return(false); }
internal ContractCustomWarningHighlighting(ICSharpStatement statement, CustomWarningValidationResult warning, ValidatedContractBlock contractBlock) { Contract.Requires(warning != null); Contract.Requires(contractBlock != null); Contract.Requires(_range != null); _range = statement.GetHighlightingRange(); _toolTip = warning.GetErrorText(); _validationResult = warning; _contractBlock = contractBlock; MethodName = warning.GetEnclosingMethodName(); }
private bool IsElseBlock(IBlock block, ICSharpStatement parentStatement) { var ifBlock = parentStatement as IIfStatement; if (ifBlock != null) { if (ifBlock.Else == block) { return(true); } } return(false); }
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress) { string type = _currentStruct.DeclaredName; ICSharpStatement anchor = null; // I wish there was documentation on this haha :) var factory = CSharpElementFactory.GetInstance(_currentStruct); var method = factory.CreateTypeMemberDeclaration("public static " + type + " Read( BinaryReader br ) {}") as IMethodDeclaration; var st = factory.CreateStatement("long start = br.BaseStream.Position;" + Environment.NewLine); method.Body.AddStatementAfter(st, anchor); st = factory.CreateStatement($"{type} ret = new {type}();"); method.Body.AddStatementAfter(st, anchor); IFieldDeclaration lastMember = null; foreach (var member in _currentStruct.FieldDeclarationsEnumerable) { string typeName = member.Type.GetPresentableName(member.Language); if (typeDict.TryGetValue(typeName, out string readStmt)) { st = factory.CreateStatement($"ret.{member.DeclaredName} = {readStmt}"); method.Body.AddStatementAfter(st, anchor); } else { // sorry lumina // string call = member.Type.IsArray() ? $"br.ReadStructures<{typeName}>( );" : $"br.ReadStructure<{typeName}>();"; st = factory.CreateStatement($"ret.{member.DeclaredName} = {typeName}.Read( br );"); method.Body.AddStatementAfter(st, anchor); } lastMember = member; } st = factory.CreateStatement("return ret;"); method.Body.AddStatementAfter(st, anchor); using (WriteLockCookie.Create()) { ModificationUtil.AddChild(_currentStruct, method); } if (lastMember != null) { return(control => control.Caret.MoveTo(lastMember.GetDocumentStartOffset().Offset, CaretVisualPlacement.DontScrollIfVisible)); } return(control => control.Caret.MoveTo(method.GetDocumentStartOffset().Offset, CaretVisualPlacement.DontScrollIfVisible)); }
static void AddContractForRequires( [NotNull] ICSharpContextActionDataProvider provider, [NotNull] Func<IExpression, IExpression> getContractExpression, [NotNull] IParameter parameter, [NotNull] IBlock body, out ICSharpStatement firstNonContractStatement) { var factory = CSharpElementFactory.GetInstance(provider.PsiModule); var parameterExpression = factory.CreateExpression("$0", parameter); AddContract( ContractKind.Requires, body, provider.PsiModule, () => getContractExpression(parameterExpression), out firstNonContractStatement); }
private CodeContractStatement(ICSharpStatement statement, IInvocationExpression invocationExpression, CodeContractStatementType statementType) : base(statement) { Contract.Requires(invocationExpression != null); _invocationExpression = invocationExpression; _statementType = statementType; // Due to weird bug in CC compiler, I can't use the same variable in Contract.Requires // and in lambda expression. _codeContractExpression = JetBrains.Util.Lazy.Lazy.Of( () => Assertions.ContractStatementFactory.TryCreateAssertion(_invocationExpression)); }
private static bool InsideInnerStatement(ICSharpStatement statement) { return(statement.IsInside <IIfStatement>() || statement.IsInside <IForStatement>() || statement.IsInside <IWhileStatement>() || statement.IsInside <IForeachStatement>() || statement.IsInside <ISwitchStatement>() || IsInCaseBlock(statement) || statement.IsInside <ICatchClause>() || IsInFinally(statement) || statement.IsInside <IUsingStatement>()); }
private CodeContractStatement(ICSharpStatement statement, IInvocationExpression invocationExpression, CodeContractStatementType statementType) : base(statement) { Contract.Requires(invocationExpression != null); _invocationExpression = invocationExpression; _statementType = statementType; // Due to weird bug in CC compiler, I can't use the same variable in Contract.Requires // and in lambda expression. _codeContractExpression = JetBrains.Util.Lazy.Of( () => Assertions.ContractStatementFactory.TryCreateAssertion(_invocationExpression), true); }
public PreconditionConverterExecutor(ICSharpStatement preconditionStatement, IPrecondition precondition, PreconditionType sourcePreconditionType, PreconditionType destinationPreconditionType) : base(preconditionStatement) { Contract.Requires(precondition != null); Contract.Requires(sourcePreconditionType != destinationPreconditionType); _precondition = precondition; _sourcePreconditionType = sourcePreconditionType; _destinationPreconditionType = destinationPreconditionType; InitializeConverters(); }
private static bool IsInCaseBlock(ICSharpStatement statement) { var block = BlockNavigator.GetByStatement(statement); while (block != null) { if (block.Parent is ISwitchStatement) { return(true); } block = block.Parent as IBlock; } return(false); }
private static ContractStatement CreateSpecialInvocationContractStatement(ICSharpStatement statement) { var method = statement.GetInvokedMethod(); if (method == null) return null; var validatorAttribute = new ClrTypeName("System.Diagnostics.Contracts.ContractArgumentValidatorAttribute"); if (method.HasAttributeInstance(validatorAttribute, false)) return ContractValidatorStatement.TryCreate(statement, method); var abbreviationAttribute = new ClrTypeName("System.Diagnostics.Contracts.ContractAbbreviatorAttribute"); if (method.HasAttributeInstance(abbreviationAttribute, false)) return ContractAbbreviationStatement.TryCreate(statement, method); return null; }
public static IPrecondition TryCreatePrecondition(ICSharpStatement statement) { var ifThrowPrecondition = IfThrowPrecondition.TryCreate(statement); if (ifThrowPrecondition != null) { return(ifThrowPrecondition); } var requires = CodeContractAssertion.TryCreate(statement) as IPrecondition; if (requires != null) { return(requires); } return(null); }
static void AddContractForRequires( [NotNull] ICSharpContextActionDataProvider provider, [NotNull] Func <IExpression, IExpression> getContractExpression, [NotNull] IParameter parameter, [NotNull] IBlock body, out ICSharpStatement firstNonContractStatement) { var factory = CSharpElementFactory.GetInstance(body); var parameterExpression = factory.CreateExpression("$0", parameter); AddContract( ContractKind.Requires, body, provider.PsiModule, () => getContractExpression(parameterExpression), out firstNonContractStatement); }
private static bool IsInFinally(ICSharpStatement statement) { var block = BlockNavigator.GetByStatement(statement); while (block != null) { if (block.Parent is ITryStatement) { // Looks ugly, but I don't know how to check that the statement in the finally block only! var tryStatement = (ITryStatement)block.Parent; return(tryStatement.FinallyBlock == block); } block = block.Parent as IBlock; } return(false); }
public static IInvocationExpression AsInvocationExpression(ICSharpStatement statement) { var expressionStatement = statement as IExpressionStatement; if (expressionStatement == null) { return(null); } var visitor = new InvocationVisitor(); expressionStatement.Expression.Accept(visitor); if (visitor.InvocationExpression == null) { return(null); } return(visitor.InvocationExpression); }
public static ICSharpStatement AddStatementsTo(this IBlock block, IEnumerable<ICSharpStatement> statements, ICSharpStatement selectedStatement) { Contract.Requires(block != null); Contract.Requires(statements != null); Contract.Requires(selectedStatement != null); ICSharpStatement result = null; ICSharpStatement localAnchor = null; foreach (var s in statements) { localAnchor = block.AddStatementAfter(s, localAnchor); if (s == selectedStatement) result = localAnchor; } return result; }
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress) { var anchor = myLoopStatement as ICSharpStatement; var declaredElement = MonoBehaviourMoveUtil.GetDeclaredElementFromParentDeclaration(myToMove); var baseName = myVariableName ?? MonoBehaviourMoveUtil.CreateBaseName(myToMove, declaredElement); var name = NamingUtil.GetUniqueName(myToMove, baseName, NamedElementKinds.Locals, collection => collection.Add(myToMove.Type(), new EntryOptions()), de => !de.Equals(declaredElement)); var factory = CSharpElementFactory.GetInstance(myToMove); var originMyToMove = myToMove.CopyWithResolve(); MonoBehaviourMoveUtil.RenameOldUsages(myToMove, declaredElement, name, factory); ICSharpStatement declaration = factory.CreateStatement("var $0 = $1;", name, originMyToMove); StatementUtil.InsertStatement(declaration, ref anchor, true); return(null); }
static void AddContractForEnsures( [NotNull] ICSharpContextActionDataProvider provider, [NotNull] Func<IExpression, IExpression> getContractExpression, [NotNull] IParameter parameter, [NotNull] IBlock body, out ICSharpStatement firstNonContractStatement) { var factory = CSharpElementFactory.GetInstance(provider.PsiModule); var contractType = new DeclaredTypeFromCLRName(ClrTypeNames.Contract, provider.PsiModule).GetTypeElement(); var parameterExpression = factory.CreateExpression("$0", parameter); var expression = factory.CreateExpression( string.Format("$0.{0}(out $1)", nameof(Contract.ValueAtReturn)), contractType, parameterExpression); AddContract(ContractKind.Ensures, body, provider.PsiModule, () => getContractExpression(expression), out firstNonContractStatement); }
static void AddContractForEnsures( [NotNull] ICSharpContextActionDataProvider provider, [NotNull] Func <IExpression, IExpression> getContractExpression, [NotNull] IParameter parameter, [NotNull] IBlock body, out ICSharpStatement firstNonContractStatement) { var factory = CSharpElementFactory.GetInstance(body); var contractType = TypeElementUtil.GetTypeElementByClrName(PredefinedType.CONTRACT_FQN, provider.PsiModule); var parameterExpression = factory.CreateExpression("$0", parameter); var expression = factory.CreateExpression( string.Format("$0.{0}(out $1)", nameof(Contract.ValueAtReturn)), contractType, parameterExpression); AddContract(ContractKind.Ensures, body, provider.PsiModule, () => getContractExpression(expression), out firstNonContractStatement); }
internal static CodeContractStatement TryCreate(ICSharpStatement statement) { Contract.Requires(statement != null); var invocationExpression = Impl.StatementUtils.AsInvocationExpression(statement); if (invocationExpression == null) { return(null); } var contractAssertion = GetContractAssertionType(invocationExpression); if (contractAssertion == null) { return(null); } return(new CodeContractStatement(statement, invocationExpression, contractAssertion.Value)); }
internal static IfThrowPrecondition TryCreate(ICSharpStatement statement) { Contract.Requires(statement != null); var ifStatement = statement as IIfStatement; if (ifStatement == null || ifStatement.Condition == null) { return(null); } var predicateExpression = PredicateExpression.Create(ifStatement.Condition); IThrowStatement throwStatement = ParseThrowStatement(ifStatement); if (throwStatement == null) { return(null); } var arguments = throwStatement.GetArguments().ToList(); var exceptionType = throwStatement.GetExceptionType(); if (exceptionType == null) { return(null); } // We can deal with any exception derived from the ArgumentException if (!IsDerivedOrEqualFor(exceptionType, typeof(ArgumentException)) || arguments.Count == 0) { return(null); } var message = arguments.Skip(1).FirstOrDefault() .Return(ExtractMessage, NoMessage.Instance); // message is optional and should be second argument return(new IfThrowPrecondition(ifStatement, predicateExpression, message, exceptionType)); }
public static ICSharpStatement AddStatementsTo(this IBlock block, IEnumerable <ICSharpStatement> statements, ICSharpStatement selectedStatement) { Contract.Requires(block != null); Contract.Requires(statements != null); Contract.Requires(selectedStatement != null); ICSharpStatement result = null; ICSharpStatement localAnchor = null; foreach (var s in statements) { localAnchor = block.AddStatementAfter(s, localAnchor); if (s == selectedStatement) { result = localAnchor; } } return(result); }
public static IBlock GetTargetBlock(ICSharpStatement currentStatement) { // Looking for the block that is not a part of Try statement ICSharpStatement statement = currentStatement; while (true) { IBlock result = BlockNavigator.GetByStatement(statement); if (result == null) { return(null); } var tryStatement = result.GetContainingNode <ITryStatement>(); if (tryStatement == null) { return(result); } statement = tryStatement; } }
public static ICSharpStatement AddStatementsBefore(this ICSharpStatement anchor, IEnumerable<ICSharpStatement> statements, ICSharpStatement selectedStatement) { Contract.Requires(anchor != null); Contract.Requires(statements != null); Contract.Requires(selectedStatement != null); var localAnchor = anchor; var parent = BlockNavigator.GetByStatement(localAnchor); Contract.Assert(parent != null, "Can't find parent for the last contract statement."); ICSharpStatement result = null; foreach (var s in statements) { localAnchor = parent.AddStatementBefore(s, localAnchor); if (s == selectedStatement) result = localAnchor; } return result; }
protected CognitiveComplexityHintBase(ITreeNode node, DocumentOffset offset, int value) { _node = node; _offset = offset; Value = value; Description = node switch { IWhileStatement _ => "While-Statement (increases nesting)", ISwitchStatement _ => "Switch-Statement (increases nesting)", IDoStatement _ => "Do-While-Statement (increases nesting)", IIfStatement _ => "If-Statement (increases nesting)", IForStatement _ => "For-Statement (increases nesting)", IForeachStatement _ => "Foreach-Statement (increases nesting)", ICatchClause _ => "Catch-Clause (increases nesting)", IGotoStatement _ => "Goto-Statement", IBreakStatement _ => "Break-Statement", IConditionalOrExpression _ => "First/alternating conditional Expression", IConditionalAndExpression _ => "First/alternating conditional Expression", ICSharpStatement _ => "If-Statement (increases nesting)", ICSharpExpression _ => "Recursive Call", _ => throw new NotSupportedException(node.GetType().FullName) }; }
internal static ContractValidatorStatement TryCreate(ICSharpStatement statement, IMethod method) { Contract.Requires(statement != null); return new ContractValidatorStatement(statement); }
private ContractValidatorStatement(ICSharpStatement statement) : base(statement) {}
internal ContractRequires(ICSharpStatement statement, IInvocationExpression invocationExpression, PredicateExpression predicateExpression, Message message) : base(statement, predicateExpression, message) { GenericArgumentDeclaredType = GetGenericRequiresType(invocationExpression); }
ContractStatementInfo(ContractKind contractKind, [NotNull] ICSharpStatement statement) { ContractKind = contractKind; Statement = statement; }
internal ContractInvariant(ICSharpStatement statement, PredicateExpression predicateExpression, Message message) : base(statement, predicateExpression, message) { }
protected ValidationResult(ICSharpStatement statement) { Contract.Requires(statement != null); _statement = statement; }
public static CodeContractAssertion TryCreateAssertion(ICSharpStatement statement) { return(CodeContractAssertion.TryCreate(statement)); }
private void ReplaceStatements(ICSharpStatement original, ICSharpStatement @new) { _currentFile.GetPsiServices().Transactions.Execute("Replace Requires", () => { WriteLockCookie.Execute(() => ModificationUtil.ReplaceChild(original, @new)); }); }
protected ValidationResultContract(ICSharpStatement statement) : base(statement) { }
protected static void AddContract( ContractKind contractKind, [NotNull] IBlock body, [NotNull] IPsiModule psiModule, [NotNull] Func <IExpression> getContractExpression, out ICSharpStatement firstNonContractStatement) { var contractExpression = getContractExpression(); Debug.Assert(contractExpression != null); var statement = CreateContractStatement(contractKind, psiModule, contractExpression); var contractStatements = ContractStatementInfo.CreateContractStatementInfos(body); switch (contractKind) { case ContractKind.Requires: var lastRequiresStatement = (from s in contractStatements where s.ContractKind == ContractKind.Requires select s.Statement) .LastOrDefault(); if (lastRequiresStatement != null) { statement = body.AddStatementAfter(statement, lastRequiresStatement); firstNonContractStatement = null; } else { var firstEnsuresOrEnsuresOnThrowStatement = ( from s in contractStatements where s.ContractKind == ContractKind.Ensures || s.ContractKind == ContractKind.EnsuresOnThrow select s.Statement).FirstOrDefault(); if (firstEnsuresOrEnsuresOnThrowStatement != null) { statement = body.AddStatementBefore(statement, firstEnsuresOrEnsuresOnThrowStatement); firstNonContractStatement = null; } else { firstNonContractStatement = body.StatementsEnumerable.FirstOrDefault(); statement = body.AddStatementBefore(statement, firstNonContractStatement); } } break; case ContractKind.Ensures: var lastEnsuresOrLastRequiresStatement = (from s in contractStatements where s.ContractKind == ContractKind.Ensures select s.Statement).LastOrDefault() ?? (from s in contractStatements where s.ContractKind == ContractKind.Requires select s.Statement).LastOrDefault(); if (lastEnsuresOrLastRequiresStatement != null) { statement = body.AddStatementAfter(statement, lastEnsuresOrLastRequiresStatement); firstNonContractStatement = null; } else { var lastEnsuresOnThrowStatement = (from s in contractStatements where s.ContractKind == ContractKind.EnsuresOnThrow select s.Statement).FirstOrDefault(); if (lastEnsuresOnThrowStatement != null) { statement = body.AddStatementBefore(statement, lastEnsuresOnThrowStatement); firstNonContractStatement = null; } else { firstNonContractStatement = body.StatementsEnumerable.FirstOrDefault(); body.AddStatementBefore(statement, firstNonContractStatement); } } break; case ContractKind.Invariant: var lastInvariantStatement = (from s in contractStatements where s.ContractKind == ContractKind.Invariant select s.Statement) .LastOrDefault(); statement = body.AddStatementAfter(statement, lastInvariantStatement); firstNonContractStatement = null; break; default: throw new ArgumentOutOfRangeException(nameof(contractKind)); } ContextActionUtils.FormatWithDefaultProfile(statement); }
internal ContractInvariant(ICSharpStatement statement, PredicateExpression predicateExpression, Message message) : base(statement, predicateExpression, message) {}