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();
}
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 ContractRequires(ICSharpStatement statement, IInvocationExpression invocationExpression,
PredicateExpression predicateExpression, Message message)
: base(statement, predicateExpression, message)
{
GenericArgumentDeclaredType = GetGenericRequiresType(invocationExpression);
}
internal ContractInvariant(ICSharpStatement statement, PredicateExpression predicateExpression, Message message)
: base(statement, predicateExpression, message)
{}
