public override void AddContracts(
ICSharpContextActionDataProvider provider,
Func<IExpression, IExpression> getContractExpression,
out ICollection<ICSharpStatement> firstNonContractStatements)
{
var contractInvariantMethodDeclaration = classLikeDeclaration.EnsureContractInvariantMethod(provider.PsiModule);
if (contractInvariantMethodDeclaration.Body != null)
{
var factory = CSharpElementFactory.GetInstance(provider.PsiModule);
var expression = factory.CreateExpression("$0", declaration.DeclaredElement);
ICSharpStatement firstNonContractStatement;
AddContract(
ContractKind.Invariant,
contractInvariantMethodDeclaration.Body,
provider.PsiModule,
() => getContractExpression(expression),
out firstNonContractStatement);
firstNonContractStatements = firstNonContractStatement != null ? new[] { firstNonContractStatement } : null;
}
else
{
firstNonContractStatements = null;
}
}
public ReturnTypeEnsuresAvailability(ICSharpContextActionDataProvider provider)
{
Contract.Requires(provider != null);
_provider = provider;
IsAvailable = ComputeIsAvailable(out _currentFunction);
}
public AddRequiresExecutor(ICSharpContextActionDataProvider provider, bool shouldBeGeneric,
ICSharpFunctionDeclaration functionDeclaration, string parameterName, IClrTypeName propertyType)
: this(provider, shouldBeGeneric, new []{functionDeclaration}, parameterName, propertyType)
{
Contract.Requires(provider != null);
_provider = provider;
}
public override void AddContracts(
ICSharpContextActionDataProvider provider,
Func<IExpression, IExpression> getContractExpression,
out ICollection<ICSharpStatement> firstNonContractStatements)
{
if (declaration.Body != null)
{
var factory = CSharpElementFactory.GetInstance(provider.PsiModule);
var contractType = new DeclaredTypeFromCLRName(ClrTypeNames.Contract, provider.PsiModule).GetTypeElement();
Debug.Assert(declaration.DeclaredElement != null);
var expression = factory.CreateExpression(
string.Format("$0.{0}<$1>()", nameof(Contract.Result)),
contractType,
declaration.DeclaredElement.ReturnType);
ICSharpStatement firstNonContractStatement;
AddContract(
ContractKind.Ensures,
declaration.Body,
provider.PsiModule,
() => getContractExpression(expression),
out firstNonContractStatement);
firstNonContractStatements = firstNonContractStatement != null ? new[] { firstNonContractStatement } : null;
}
else
{
firstNonContractStatements = null;
}
}
public static AddContractClassAvailability IsAvailableForSelectedType(ICSharpContextActionDataProvider provider)
{
Contract.Requires(provider != null);
Contract.Ensures(Contract.Result<AddContractClassAvailability>() != null);
return new AddContractClassAvailability(provider, false, null);
}
public static AddContractClassAvailability IsAvailableForSelectedMethod(ICSharpContextActionDataProvider provider, ICSharpFunctionDeclaration selectedFunction = null)
{
Contract.Requires(provider != null);
Contract.Ensures(Contract.Result<AddContractClassAvailability>() != null);
return new AddContractClassAvailability(provider, true, selectedFunction);
}
private static ICSharpStatement CreateArgumentCheckStatement(ICSharpContextActionDataProvider provider, string pattern, IRegularParameterDeclaration parameterDeclaration)
{
Argument.IsNotNull(() => provider);
Argument.IsNotNullOrWhitespace(() => pattern);
Argument.IsNotNull(() => parameterDeclaration);
var catelArgumentType = TypeHelper.CreateTypeByCLRName(CatelCore.Argument, provider.PsiModule, provider.SelectedElement.GetResolveContext());
return provider.ElementFactory.CreateStatement(pattern, catelArgumentType.GetTypeElement(), parameterDeclaration.DeclaredName);
}
protected EnsuresAvailability(ICSharpContextActionDataProvider provider,
ReturnTypeEnsuresAvailability returnTypeEnsuresAvailability)
{
Contract.Requires(provider != null);
Contract.Requires(returnTypeEnsuresAvailability != null);
_provider = provider;
_returnTypeEnsuresAvailability = returnTypeEnsuresAvailability;
IsAvailable = ComputeIsAvailable(out _selectedFunction);
}
private EnsuresExecutor(ICSharpContextActionDataProvider provider, ICSharpFunctionDeclaration selectedFunction,
EnsuresType ensuresType)
: base(provider)
{
Contract.Requires(provider != null);
Contract.Requires(selectedFunction != null);
Contract.Requires(Enum.IsDefined(typeof (EnsuresType), ensuresType));
_selectedFunction = selectedFunction;
_ensuresFactoryMethod = CreateEnsuresFactoryMethod(ensuresType);
}
private InvariantAvailability(ICSharpContextActionDataProvider provider,
FieldOrPropertyDeclaration selectedElement)
{
Contract.Requires(provider != null);
_classDeclaration = provider.GetSelectedElement<IClassLikeDeclaration>(true, true);
_selectedElement = selectedElement;
IsAvailable = AnalyzeAvailability();
if (IsAvailable)
SelectedMemberName = _selectedElement.Name;
}
public static InvariantAvailability Create(ICSharpContextActionDataProvider provider)
{
Contract.Requires(provider != null);
Contract.Ensures(Contract.Result<InvariantAvailability>() != null);
var fieldOrPropertyDeclaration = TryCreateFieldOrProperty(provider);
if (fieldOrPropertyDeclaration == null)
return InvariantUnavailable;
return new InvariantAvailability(provider, fieldOrPropertyDeclaration.Value);
}
private static FieldOrPropertyDeclaration? TryCreateFieldOrProperty(ICSharpContextActionDataProvider provider)
{
var fieldDeclaration = provider.GetSelectedElement<IFieldDeclaration>(true, true);
if (fieldDeclaration != null && IsFieldDeclarationValid(fieldDeclaration))
return FieldOrPropertyDeclaration.FromFieldDeclaration(fieldDeclaration);
var propertyDeclaration = provider.GetSelectedElement<IPropertyDeclaration>(true, true);
if (propertyDeclaration != null && IsPropertyDeclarationValid(propertyDeclaration))
return FieldOrPropertyDeclaration.FromPropertyDeclaration(propertyDeclaration);
return null;
}
protected ContextActionExecutorBase(ICSharpContextActionDataProvider provider)
{
Contract.Requires(provider != null);
_factory = provider.ElementFactory;
Contract.Assert(provider.SelectedElement != null,
"Can't create executor if SelectedElement is null");
_currentFile = (ICSharpFile)provider.SelectedElement.GetContainingFile();
_psiServices = provider.PsiServices;
_psiModule = provider.PsiModule;
}
public ComboEnsuresAvailability(ICSharpContextActionDataProvider provider)
{
Contract.Requires(provider != null);
_provider = provider;
if (IsAbstractClassOrInterface()
&& IsEnsuresAvailableFor(out _selectedFunctionDeclaration)
&& CanAddContractForSelectedMethod(out _addContractAvailability,
_selectedFunctionDeclaration))
{
IsAvailable = true;
}
}
public AddRequiresExecutor(ICSharpContextActionDataProvider provider, bool shouldBeGeneric,
IEnumerable<ICSharpFunctionDeclaration> functionsDeclaration, string parameterName, IClrTypeName propertyType)
: base(provider)
{
Contract.Requires(functionsDeclaration != null);
Contract.Requires(parameterName != null);
Contract.Requires(propertyType != null);
_provider = provider;
_shouldBeGeneric = shouldBeGeneric;
_functionsDeclaration = functionsDeclaration;
_parameterName = parameterName;
_propertyType = propertyType;
}
public ComboEnsuresExecutor(ICSharpContextActionDataProvider provider,
AddContractClassAvailability addContractAvailability,
ICSharpFunctionDeclaration selectedFunctionDeclaration)
: base(provider)
{
Contract.Requires(provider != null);
Contract.Requires(addContractAvailability != null);
Contract.Requires(addContractAvailability.IsAvailable);
Contract.Requires(selectedFunctionDeclaration != null);
_provider = provider;
_addContractAvailability = addContractAvailability;
_selectedFunctionDeclaration = selectedFunctionDeclaration;
}
private AddContractClassAvailability(ICSharpContextActionDataProvider provider,
bool contractForSelectedMethod, ICSharpFunctionDeclaration selectedFunctionDeclaration)
{
Contract.Requires(provider != null);
Contract.Requires(provider.SelectedElement != null);
_provider = provider;
_contractForSelectedMethod = contractForSelectedMethod;
_selectedFunctionDeclaration = selectedFunctionDeclaration ?? GetSelectedFunction();
IsAvailable = ComputeIsAvailable();
if (IsAvailable)
{
ComputeSelectedDeclarationMember();
}
}
public InvariantActionExecutor(InvariantAvailability invariantAvailability,
ICSharpContextActionDataProvider provider)
: base(provider)
{
Contract.Requires(invariantAvailability != null);
Contract.Requires(provider != null);
Contract.Requires(invariantAvailability.IsAvailable);
_invariantAvailability = invariantAvailability;
_provider = provider;
// TODO: look at this class CSharpStatementNavigator
_classDeclaration = provider.GetSelectedElement<IClassLikeDeclaration>(true, true);
Contract.Assert(provider.SelectedElement != null);
}
public AddContractClassExecutor(ICSharpContextActionDataProvider provider, AddContractClassAvailability addContractForAvailability,
ICSharpFunctionDeclaration requiredFunction = null)
{
Contract.Requires(provider != null);
Contract.Requires(addContractForAvailability != null);
Contract.Requires(addContractForAvailability.IsAvailable);
_addContractForAvailability = addContractForAvailability;
_provider = provider;
_requiredFunction = requiredFunction;
_factory = _provider.ElementFactory;
// TODO: look at this class CSharpStatementNavigator
Contract.Assert(provider.SelectedElement != null);
_currentFile = (ICSharpFile)provider.SelectedElement.GetContainingFile();
}
public AddContractForExecutor(AddContractForAvailability addContractForAvailability,
ICSharpContextActionDataProvider provider)
{
Contract.Requires(addContractForAvailability != null);
Contract.Requires(addContractForAvailability.IsAvailable);
Contract.Requires(provider != null);
_addContractForAvailability = addContractForAvailability;
_provider = provider;
_factory = CSharpElementFactory.GetInstance(provider.PsiModule);
// TODO: look at this class CSharpStatementNavigator
_classDeclaration = provider.GetSelectedElement<IClassLikeDeclaration>(true, true);
Contract.Assert(provider.SelectedElement != null);
_currentFile = (ICSharpFile)provider.SelectedElement.GetContainingFile();
}
protected ReturnTypeEnsuresAvailabilityContract(ICSharpContextActionDataProvider provider)
: base(provider)
{}
public RunApproximatorAction(ICSharpContextActionDataProvider provider)
{
_provider = provider;
}
public DependencyCheckAction(ICSharpContextActionDataProvider provider)
{
_provider = provider;
}
public PureAttributeAction([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public AddTooltipAttributeAction(ICSharpContextActionDataProvider dataProvider)
: base(dataProvider, ourSubmenuAnchor)
{
}
public InitializeComponentContextActionBase(ICSharpContextActionDataProvider dataProvider)
{
myDataProvider = dataProvider;
}
public RemoveAssertNotNull([NotNull] ICSharpContextActionDataProvider provider) => this.provider = provider;
public TimeSpanPositive([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public IntPtrUIntPtrZero([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public ReverseStringAction(ICSharpContextActionDataProvider provider)
{
_provider = provider;
}
public TimeSpanZeroOrNegative([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
protected override IContextAction CreateContextAction(ICSharpContextActionDataProvider dataProvider)
{
return((TContextAction)Activator.CreateInstance(typeof(TContextAction), new object[] { dataProvider }));
}
public RemoveGreedyAttributeAction([NotNull] ICSharpContextActionDataProvider provider) : base(provider, AutoFixtureConstants.GreedyAttributeType)
{
}
public EnumCheckReturnTypeEnsuresAvailability(ICSharpContextActionDataProvider provider) : base(provider)
{
}
public ExcludePropertyFromSerializationContextAction(ICSharpContextActionDataProvider provider)
: base(provider)
{
}
public IsNotNullOrEmptyContextAction(ICSharpContextActionDataProvider provider)
: base(provider)
{
}
public MakeMethodStaticContextActions(ICSharpContextActionDataProvider provider)
{
_provider = provider;
}
/// <summary>Initializes a new instance of the <see cref="GenerateSwitchContextAction"/> class.</summary>
/// <param name="provider">The provider.</param>
public GenerateSwitchContextAction(ICSharpContextActionDataProvider provider)
: base(provider)
{
}
public InitializePropertyComponentContextAction(ICSharpContextActionDataProvider dataProvider)
: base(dataProvider)
{
}
public FillParamWithMockContextAction(ICSharpContextActionDataProvider dataProvider)
{
_dataProvider = dataProvider;
}
public AnnotateWithLinqTunnel([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public FillWithMockFieldsContextAction(ICSharpContextActionDataProvider dataProvider)
{
_dataProvider = dataProvider;
}
protected AutoFixtureAttributeActionBase([NotNull] ICSharpContextActionDataProvider provider, [NotNull] IClrTypeName attributeType)
{
this.Provider = provider;
this.AttributeType = attributeType;
}
public NotNull([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public EnumKnownValues([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public AnnotateWithInstantHandle([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
protected override IContextAction CreateContextAction(ICSharpContextActionDataProvider dataProvider)
{
return new CSharpUseIntMaxValueAction(dataProvider);
}
public SignedNumericZeroOrNegative([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
public EnumCheckReturnTypeEnsuresAvailability(ICSharpContextActionDataProvider provider) : base(provider)
{}
public CreateOrBrowseTestFileAction([NotNull] ICSharpContextActionDataProvider provider)
{
this._provider = provider;
}
protected ReturnTypeEnsuresAvailabilityContract(ICSharpContextActionDataProvider provider)
: base(provider)
{
}
protected GenericContextAction(string actionName, ICSharpContextActionDataProvider provider)
{
_actionName = actionName;
Provider = provider;
}
protected AddInspectorAttributeAction(ICSharpContextActionDataProvider dataProvider, IAnchor anchor)
{
myDataProvider = dataProvider;
myAnchor = anchor;
}
public FillWithMockLocalVariableContextAction(ICSharpContextActionDataProvider dataProvider)
{
_dataProvider = dataProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentUncaughtExceptionsContextAction"/> class.
/// </summary>
/// <param name="provider">
/// The provider.
/// </param>
public DocumentUncaughtExceptionsContextAction(ICSharpContextActionDataProvider provider)
: base(provider)
{
}
public abstract void AddContracts(
[NotNull] ICSharpContextActionDataProvider provider,
[NotNull] Func <IExpression, IExpression> getContractExpression,
[ItemNotNull] out ICollection <ICSharpStatement> firstNonContractStatements);
public EnumCheckEnsuresContextAction(ICSharpContextActionDataProvider provider)
: base(provider)
{}
public MathodToAsyncConverter(ICSharpContextActionDataProvider provider)
{
Provider = provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="CheckAssignmentContextAction"/> class.
/// </summary>
/// <param name="provider">
/// The provider.
/// </param>
public CheckAssignmentContextAction(ICSharpContextActionDataProvider provider)
: base(provider)
{
}
public AssertParameterNotNullAction([NotNull] ICSharpContextActionDataProvider provider) : base(provider)
{
}
