private bool AnalyzeValuesAttribute(IRegularParameterDeclaration parameterDeclaration, IHighlightingConsumer consumer)
{
var parameterHasAnyDataSource = false;
foreach (var attribute in parameterDeclaration.AttributesEnumerable)
{
if (attribute.IsAttributeOrDerivedFrom(ParameterizedTests.ParameterDataSourceInterface,
// NUnit 2 support:
ParameterizedTests.ValueSourceAttribute))
{
parameterHasAnyDataSource = true;
}
if (attribute.IsAttributeOrDerivedFrom(ParameterizedTests.ValuesAttribute))
{
parameterHasAnyDataSource = true;
var arguments = GetArgumentsOfTestDataAttribute(attribute);
foreach (var argument in arguments)
{
AnalyzeArgumentType(argument.Expression, parameterDeclaration, consumer);
}
}
}
return(parameterHasAnyDataSource);
}
protected override bool IsArgumentChecked(
ICSharpFunctionDeclaration methodDeclaration, IRegularParameterDeclaration parameterDeclaration)
{
// TODO: Verify the completion of the condition || (InvokationDetectionHelper.IsMaximunInvoked(methodDeclaration.Body.GetText(), parameterDeclaration.DeclaredName) && InvokationDetectionHelper.IsMinimalInvoked(methodDeclaration.Body.GetText(), parameterDeclaration.DeclaredName));
return ArgumentCheckStatementDetectionHelper.IsNotOutOfRangeInvoked(
methodDeclaration.Body.GetText(), parameterDeclaration.DeclaredName);
}
public override sealed bool IsAvailable(IUserDataHolder cache)
{
using (ReadLockCookie.Create())
{
if (Provider.SelectedElement != null)
{
var catelArgumentType = TypeHelper.CreateTypeByCLRName(CatelCore.Argument, Provider.PsiModule, Provider.SelectedElement.GetResolveContext());
_parameterDeclaration = null;
_methodDeclaration = null;
if (catelArgumentType.GetTypeElement() != null)
{
if (Provider.SelectedElement != null && Provider.SelectedElement.Parent is IRegularParameterDeclaration)
{
_parameterDeclaration = Provider.SelectedElement.Parent as IRegularParameterDeclaration;
if (_parameterDeclaration.Parent != null && _parameterDeclaration.Parent != null
&& _parameterDeclaration.Parent.Parent is ICSharpFunctionDeclaration)
{
_methodDeclaration =
_parameterDeclaration.Parent.Parent as ICSharpFunctionDeclaration;
}
}
}
}
}
return _parameterDeclaration != null && IsArgumentTypeTheExpected(_parameterDeclaration.Type)
&& _methodDeclaration != null
&& !IsArgumentChecked(_methodDeclaration, _parameterDeclaration);
}
public WrongParameterTypeError(IRegularParameterDeclaration parameterDeclaration, IType type)
{
myParameterDeclaration = parameterDeclaration;
myType = type;
myMessage = string.Format(
"Member name parameter type must be implicitly convertible to '{0}'",
Type.GetPresentableName(CSharpLanguage.Instance));
}
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);
}
private static (NamedElementKinds?, IReferenceName) GetKindAndDeclaration(ILocalVariableDeclaration localVarDeclaration, IFieldDeclaration fieldDeclaration,
IRegularParameterDeclaration regularParameterDeclaration)
{
NamedElementKinds?kind = null;
IReferenceName scalarTypeName = null;
if (localVarDeclaration != null)
{
kind = NamedElementKinds.Locals;
scalarTypeName = localVarDeclaration.GetScalarTypename();
}
else if (fieldDeclaration != null)
{
scalarTypeName = fieldDeclaration.GetScalarTypename();
var isPrivate = fieldDeclaration.GetAccessRights().Has(AccessRights.PRIVATE);
if (fieldDeclaration.IsStatic)
{
if (isPrivate)
{
kind = fieldDeclaration.IsReadonly ? NamedElementKinds.PrivateStaticReadonly : NamedElementKinds.PrivateStaticFields;
}
else
{
kind = fieldDeclaration.IsReadonly ? NamedElementKinds.StaticReadonly : NamedElementKinds.PublicFields;
}
}
else
{
kind = isPrivate ? NamedElementKinds.PrivateInstanceFields : NamedElementKinds.PublicFields;
}
}
else if (regularParameterDeclaration != null)
{
kind = NamedElementKinds.Parameters;
scalarTypeName = regularParameterDeclaration.ScalarTypeName;
}
return(kind, scalarTypeName);
}
/// <summary>
/// Replace empty strings with string dot empty.
/// </summary>
/// <param name="node">
/// The node to process.
/// </param>
public static void ReplaceEmptyStringsWithStringDotEmpty(ITreeNode node)
{
for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling)
{
if (currentNode is ITokenNode)
{
ITokenNode tokenNode = currentNode as ITokenNode;
if (tokenNode.GetTokenType().IsStringLiteral)
{
IAttribute attribute = tokenNode.GetContainingNode <IAttribute>(true);
ISwitchLabelStatement switchLabelStatement = tokenNode.GetContainingNode <ISwitchLabelStatement>(true);
IConstantDeclaration constantDeclaration = tokenNode.GetContainingNode <IConstantDeclaration>(true);
IRegularParameterDeclaration parameterDeclaration = tokenNode.GetContainingNode <IRegularParameterDeclaration>(true);
// Not for attributes, switch labels, constant declarations, or parameter declarations
if (attribute == null && switchLabelStatement == null && constantDeclaration == null && parameterDeclaration == null)
{
string text = currentNode.GetText();
if (text == "\"\"" || text == "@\"\"")
{
const string NewText = "string.Empty";
ITokenNode newLiteral =
(ITokenNode)
CSharpTokenType.STRING_LITERAL_REGULAR.Create(new JetBrains.Text.StringBuffer(NewText), new TreeOffset(0), new TreeOffset(NewText.Length));
using (WriteLockCookie.Create(true))
{
LowLevelModificationUtil.ReplaceChildRange(currentNode, currentNode, new ITreeNode[] { newLiteral });
}
}
}
}
}
if (currentNode.FirstChild != null)
{
ReadabilityRules.ReplaceEmptyStringsWithStringDotEmpty(currentNode.FirstChild);
}
}
}
protected abstract bool IsArgumentChecked(ICSharpFunctionDeclaration methodDeclaration, IRegularParameterDeclaration parameterDeclaration);
protected override bool IsArgumentCheckDocumented(XmlNode xmlDocOfTheMethod, IRegularParameterDeclaration parameterDeclaration)
{
return ExceptionXmlDocDetectionHelper.NotNullOrEmptyDocumented(xmlDocOfTheMethod.InnerXml, parameterDeclaration.DeclaredName);
}
protected override ICSharpStatement CreateArgumentCheckStatement(IRegularParameterDeclaration parameterDeclaration)
{
return ArgumentCheckStatementHelper.CreateIsNotNullOrEmptyArgumentCheckStatement(this.Provider, parameterDeclaration);
}
protected override ICSharpStatement CreateArgumentCheckStatement(
IRegularParameterDeclaration parameterDeclaration)
{
return ArgumentCheckStatementHelper.CreateImplementsInterfaceArgumentCheckStatement(
this.Provider, parameterDeclaration);
}
public static ICSharpStatement CreateIsMatchArgumentCheckStatement(ICSharpContextActionDataProvider provider, IRegularParameterDeclaration parameterDeclaration)
{
return CreateArgumentCheckStatement(provider, ArgumentCheckStatementPatterns.IsMatch, parameterDeclaration);
}
protected abstract string CreateExceptionXmlDoc(IRegularParameterDeclaration parameterDeclaration);
protected abstract ICSharpStatement CreateArgumentCheckStatement(IRegularParameterDeclaration parameterDeclaration);
protected override string CreateExceptionXmlDoc(IRegularParameterDeclaration parameterDeclaration)
{
return ExceptionXmlDocHelper.GetImplementsInterfaceExceptionXmlDoc(parameterDeclaration.DeclaredName);
}
private static bool GetMatchingParameterDeclaration(ICSharpArgumentInfo argument,
out IRegularParameterDeclaration matchingVarDecl)
{
var matchingArgument = TreeNodeHandlerUtil.GetMatchingArgument(argument);
matchingVarDecl = matchingArgument as IRegularParameterDeclaration;
if (matchingVarDecl == null)
return true;
return false;
}
protected override bool IsArgumentCheckDocumented(
XmlNode xmlDocOfTheMethod, IRegularParameterDeclaration parameterDeclaration)
{
return false;
}
protected override string CreateExceptionXmlDoc(IRegularParameterDeclaration parameterDeclaration)
{
return ExceptionXmlDocHelper.GetIsNotNullOrEmptyExceptionXmlDoc(parameterDeclaration.DeclaredName);
}
protected override bool IsArgumentChecked(
ICSharpFunctionDeclaration methodDeclaration, IRegularParameterDeclaration parameterDeclaration)
{
return false;
}
protected override bool IsArgumentChecked(ICSharpFunctionDeclaration methodDeclaration, IRegularParameterDeclaration parameterDeclaration)
{
return ArgumentCheckStatementDetectionHelper.IsNotNullOrEmptyInvoked(methodDeclaration.Body.GetText(), parameterDeclaration.DeclaredName);
}
protected abstract bool IsArgumentCheckDocumented(XmlNode xmlDocOfTheMethod, IRegularParameterDeclaration parameterDeclaration);
