public override ReflectionHighlightingBase Validate(ReflectedTypeResolveResult resolvedType, IInvocationExpression invocation)
{
if (((IModifiersOwner)resolvedType.TypeElement).IsStatic)
{
return(new IncorrectMakeArrayTypeHighlighting(invocation, "Could not call MakeArrayType on static type."));
}
return(null);
}
public override ReflectionHighlightingBase Validate(ReflectedTypeResolveResult resolvedType, IInvocationExpression invocation)
{
if (resolvedType.TypeElement.GetElementType() != CLRDeclaredElementType.ENUM)
{
return(new IsNotEnumTypeError(invocation));
}
return(null);
}
public override ReflectionHighlightingBase Validate(ReflectedTypeResolveResult resolvedType, IInvocationExpression invocation)
{
ITypeMember resolvedMember = null;
IExpression nameArgument = NameArgument(invocation);
//We may use TypeElement here as we validate only exact matches
ITypeMember[] resolvedMembers = ResolveMember(resolvedType.TypeElement, invocation);
if (resolvedMembers.Length == 0)
{
return(new ReflectionMemberNotFoundError(nameArgument, ExpectedMemberType, resolvedType.TypeElement,
ArgumentConstantValue <BindingFlags>(BindingFlagsArgument(invocation))));
}
if (resolvedMembers.Length > 1)
{
if (!ProcessAmbigiousMembers(resolvedMembers, out resolvedMember))
{
nameArgument.UserData.PutData(ReflectedMemberReference.Key,
new ReflectedMemberReference(nameArgument,
new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(resolvedMembers), ResolveErrorType.MULTIPLE_CANDIDATES), resolvedType.TypeElement));
return(new AmbigiousMemberMatchError(nameArgument, ExpectedMemberType, GetAmbigiuityResolutionSuggestion()));
}
}
else
{
resolvedMember = resolvedMembers[0];
nameArgument.UserData.PutData(ReflectedMemberReference.Key,
new ReflectedMemberReference(nameArgument,
new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(resolvedMember), ResolveErrorType.OK), resolvedType.TypeElement));
return(ValidateBindingFlags(resolvedType.TypeElement, resolvedMember, invocation)
?? ValidateCore(resolvedType.TypeElement, resolvedMember, invocation));
}
return(null);
}
public override ReflectionHighlightingBase Validate(ReflectedTypeResolveResult resolvedType, IInvocationExpression invocation)
{
var reference = invocation.InvokedExpression as IReferenceExpression;
if (resolvedType.TypeElement == null)
{
return(null);
}
int genericArgumentsCount = GetGenericArgumentsCount(resolvedType.TypeElement);
if (genericArgumentsCount == 0)
{
return(new IncorrectMakeGenericTypeHighlighting(reference,
string.Format("Type '{0}' is not a generic type.",
resolvedType.Type.GetPresentableName(CSharpLanguage.Instance))));
}
if (resolvedType.Type.IsResolved && !resolvedType.Type.IsOpenType)
{
return(new IncorrectMakeGenericTypeHighlighting(reference,
string.Format("Type '{0}' is closed generic type.",
resolvedType.Type.GetPresentableName(CSharpLanguage.Instance))));
}
int typeArgumentCount = invocation.Arguments.Count;
bool isArgumentPassedAsParams = false;
if (typeArgumentCount != 0)
{
var typeParameters = invocation.Arguments[0].Expression as IArrayCreationExpression;
if (typeParameters != null && typeParameters.ArrayInitializer != null)
{
if (typeParameters.ArrayInitializer.ElementInitializers.Count != genericArgumentsCount)
{
return(new IncorrectMakeGenericTypeHighlighting(invocation.Arguments[0],
string.Format("Incorrect count of type parameters for type {0}.",
resolvedType.Type.GetPresentableName(CSharpLanguage.Instance))));
}
}
var argumentExpression = invocation.Arguments[0].Expression;
if (argumentExpression != null && argumentExpression.Type().IsType())
{
isArgumentPassedAsParams = true;
}
}
else
{
isArgumentPassedAsParams = true;
}
if (isArgumentPassedAsParams && typeArgumentCount != genericArgumentsCount)
{
var offset = invocation.LPar.GetTreeStartOffset();
var treeTextRange = new TreeTextRange(offset, invocation.RPar.GetTreeEndOffset());
return(new IncorrectMakeGenericTypeHighlighting(invocation,
string.Format("Incorrect count of type parameters for type {0}.",
resolvedType.Type.GetPresentableName(CSharpLanguage.Instance)),
IsValidTreeTextRange(treeTextRange) ? invocation.GetContainingFile().GetDocumentRange(treeTextRange) : (DocumentRange?)null));
}
return(null);
}
public override bool CanValidate(ReflectedTypeResolveResult reflectedType)
{
return(reflectedType.ResolvedAs == ReflectedTypeResolution.Exact || reflectedType.ResolvedAs == ReflectedTypeResolution.ExactMakeGeneric);
}
public abstract ReflectionHighlightingBase Validate(ReflectedTypeResolveResult resolvedType, IInvocationExpression invocation);
public virtual bool CanValidate(ReflectedTypeResolveResult reflectedType)
{
return(reflectedType.ResolvedAs != ReflectedTypeResolution.NotResolved);
}
public override bool CanValidate(ReflectedTypeResolveResult reflectedType)
{
return(base.CanValidate(reflectedType) && reflectedType.ResolvedAs != ReflectedTypeResolution.BaseClass);
}
