/// <summary>
/// Ensures if the declaration has more than 1 accessor that they are in the correct order.
/// </summary>
/// <param name="declarationNode">
/// The node to use.
/// </param>
public static void CheckAccessorOrder(IAccessorOwnerDeclaration declarationNode)
{
TreeNodeCollection <IAccessorDeclaration> accessorDeclarations = declarationNode.AccessorDeclarations;
if (accessorDeclarations.Count < 2)
{
// don't need to reorder because there's only 1 (or none)
return;
}
// we now know we have 2 accessors
IAccessorDeclaration firstAccessor = accessorDeclarations[0];
IAccessorDeclaration secondAccessor = accessorDeclarations[1];
if (firstAccessor.Kind == AccessorKind.GETTER || firstAccessor.Kind == AccessorKind.ADDER)
{
return;
}
IAccessorDeclaration newAccessor = firstAccessor.CopyWithResolve();
declarationNode.AddAccessorDeclarationAfter(newAccessor, secondAccessor);
declarationNode.RemoveAccessorDeclaration(firstAccessor);
LayoutRules.ClosingCurlyBracketMustBeFollowedByBlankLine(declarationNode);
}
PropertyContractInfo(ContractKind contractKind, [NotNull] IAccessorOwnerDeclaration declaration, [NotNull] IType type)
: base(contractKind, type)
{
Debug.Assert(
contractKind == ContractKind.Requires || contractKind == ContractKind.Ensures || contractKind == ContractKind.RequiresAndEnsures ||
contractKind == ContractKind.Invariant);
this.declaration = declaration;
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
ITreeNode element = Utils.GetElementAtCaret(solution, textControl);
IAccessorOwnerDeclaration declaration = element.GetContainingNode <IAccessorOwnerDeclaration>(true);
if (declaration != null)
{
OrderingRules.CheckAccessorOrder(declaration);
}
}
PropertyContractInfo(ContractKind contractKind, [NotNull] IAccessorOwnerDeclaration declaration, [NotNull] IType type) : base(
contractKind,
type)
{
Debug.Assert(
contractKind == ContractKind.Requires ||
contractKind == ContractKind.Ensures ||
contractKind == ContractKind.RequiresAndEnsures ||
contractKind == ContractKind.Invariant);
this.declaration = declaration;
}
private void AddAccessorDecl(IAccessorOwnerDeclaration decl,
KaVE.Commons.Model.SSTs.Declarations.IPropertyDeclaration propDecl)
{
foreach (var accessor in decl.AccessorDeclarations)
{
var bodyVisitor = new BodyVisitor(new UniqueVariableNameGenerator(), _marker);
var body = Lists.NewList <IKaVEStatement>();
if (accessor.Kind == AccessorKind.GETTER)
{
body = propDecl.Get;
}
if (accessor.Kind == AccessorKind.SETTER)
{
body = propDecl.Set;
}
accessor.Accept(bodyVisitor, body);
}
}
public override void AddContracts(
ICSharpContextActionDataProvider provider,
Func <IExpression, IExpression> getContractExpression,
out ICollection <ICSharpStatement> firstNonContractStatements)
{
var factory = CSharpElementFactory.GetInstance(declaration);
var propertyDeclaration = declaration as IPropertyDeclaration;
if (propertyDeclaration != null && propertyDeclaration.IsAuto)
{
var classLikeDeclaration = (IClassLikeDeclaration)declaration.GetContainingTypeDeclaration();
Debug.Assert(classLikeDeclaration != null);
var contractInvariantMethodDeclaration = classLikeDeclaration.EnsureContractInvariantMethod(provider.PsiModule);
if (contractInvariantMethodDeclaration.Body != null)
{
var expression = factory.CreateExpression("$0", declaration.DeclaredElement);
AddContract(
ContractKind.Invariant,
contractInvariantMethodDeclaration.Body,
provider.PsiModule,
() => getContractExpression(expression),
out var firstNonContractStatement);
firstNonContractStatements = firstNonContractStatement != null ? new[] { firstNonContractStatement } : null;
}
else
{
firstNonContractStatements = null;
}
return;
}
IEnumerable <IAccessorDeclaration> accessorDeclarations;
if (declaration.IsAbstract)
{
IAccessorOwnerDeclaration overriddenAccessorOwnerDeclaration = null;
var containingTypeDeclaration = declaration.GetContainingTypeDeclaration();
Debug.Assert(containingTypeDeclaration != null);
var contractClassDeclaration = containingTypeDeclaration.EnsureContractClass(provider.PsiModule);
if (propertyDeclaration != null)
{
overriddenAccessorOwnerDeclaration = propertyDeclaration.EnsureOverriddenPropertyInContractClass(contractClassDeclaration);
}
if (declaration is IIndexerDeclaration indexerDeclaration)
{
overriddenAccessorOwnerDeclaration = indexerDeclaration.EnsureOverriddenIndexerInContractClass(contractClassDeclaration);
}
Debug.Assert(overriddenAccessorOwnerDeclaration != null);
accessorDeclarations = overriddenAccessorOwnerDeclaration.AccessorDeclarations;
}
else
{
accessorDeclarations = declaration.AccessorDeclarations;
}
firstNonContractStatements = new List <ICSharpStatement>(2);
foreach (var accessorDeclaration in accessorDeclarations)
{
Debug.Assert(accessorDeclaration != null);
if (accessorDeclaration.Body != null)
{
switch (accessorDeclaration.Kind)
{
case AccessorKind.GETTER:
{
var contractType = TypeElementUtil.GetTypeElementByClrName(PredefinedType.CONTRACT_FQN, provider.PsiModule);
var resultExpression = factory.CreateExpression(
string.Format("$0.{0}<$1>()", nameof(Contract.Result)),
contractType,
Type);
AddContract(
ContractKind.Ensures,
accessorDeclaration.Body,
provider.PsiModule,
() => getContractExpression(resultExpression),
out var firstNonContractStatement);
if (firstNonContractStatement != null)
{
firstNonContractStatements.Add(firstNonContractStatement);
}
break;
}
case AccessorKind.SETTER:
{
var valueExpression = factory.CreateExpression("value");
AddContract(
ContractKind.Requires,
accessorDeclaration.Body,
provider.PsiModule,
() => getContractExpression(valueExpression),
out var firstNonContractStatement);
if (firstNonContractStatement != null)
{
firstNonContractStatements.Add(firstNonContractStatement);
}
break;
}
}
}
}
if (firstNonContractStatements.Count == 0)
{
firstNonContractStatements = null;
}
}
