private IMethodElement FindExtensionMethodInClass(IClassElement classElement, string methodName, ITypeElement callerType, Expression qualifier)
{
if (classElement == null || callerType == null)
{
return(null);
}
bool isCaseSensitiveLanguage = CodeRush.Language.IsCaseSensitive;
IMemberElementCollection classElementMembers = classElement.Members;
foreach (IElement member in classElementMembers)
{
IMethodElement method = member as IMethodElement;
if (method == null)
{
continue;
}
if (String.Compare(method.Name, methodName, !isCaseSensitiveLanguage) == 0)
{
if (method.IsExtensionMethod())
{
if (ExtendsTheCallerType(method, callerType, qualifier))
{
return(method);
}
}
}
}
return(null);
}
private bool ExtendsTheCallerType(IMethodElement method, ITypeElement callerType, Expression qualifier)
{
if (method == null || callerType == null)
return false;
if (method.Parameters.Count == 0)
return false;
ISourceTreeResolver resolver = ParserServices.SourceTreeResolver;
ExpressionCollection arguments = new ExpressionCollection();
arguments.Add(qualifier);
method = GenericElementActivator.ActivateMemberIfNeeded(resolver, method, arguments, null, ArgumentsHelper.ResolveArgumentTypes(resolver, arguments)) as IMethodElement;
if (method == null)
return false;
IParameterElement extensionParam = method.Parameters[0] as IParameterElement;
if (extensionParam == null)
return false;
ITypeReferenceExpression typeRef = extensionParam.Type;
if (typeRef == null)
return false;
ITypeElement type = typeRef.GetDeclaration() as ITypeElement;
if (type == null)
return false;
IArrayTypeElement arrayType = callerType as IArrayTypeElement;
//if (arrayType != null)
//{
// return true;
//}
//else
return ArgumentsHelper.HasParamConversion(resolver, extensionParam, callerType, qualifier, TypeConversionMode.ImplicitConversion);
}
private static IMemberElement getObjectCreationExpression_MemberElement(IObjectCreationExpression creationExp)
{
foreach (var child in creationExp.ObjectType.GetDeclaration().AllChildren)
{
IMethodElement childMethod = (child as IMethodElement);
if ((childMethod != null) && (childMethod.IsConstructor))
{
if (creationExp.Arguments.Count == childMethod.Parameters.Count)
{
if (creationExp.Arguments.Count == 0)
{
return(childMethod);
}
for (int i = 0; i < childMethod.Parameters.Count; i++)
{
if (creationExp.Arguments[i].Is(childMethod.Parameters[i].Type.GetDeclaration() as ITypeElement))
{
return(childMethod);
}
}
}
}
}
return(null);
}
public static void Emit(this ILGenerator il, OpCode opcode, IMethodElement el)
{
var m = el as IMemberInfoSource;
var methodInfo = m.MemberInfo as MethodInfo;
il.Emit(opcode, methodInfo);
}
private bool MethodHasIssue(IMethodElement method)
{
if (!method.IsTestMethod())
return false;
var assert = GetAssert(method);
var exceptionAttribute = GetExpectedExceptionAttribute(method);
return assert == null && exceptionAttribute == null;
}
private bool ExtendsTheCallerType(IMethodElement method, ITypeElement callerType, Expression qualifier)
{
if (method == null || callerType == null)
{
return(false);
}
if (method.Parameters.Count == 0)
{
return(false);
}
ISourceTreeResolver resolver = ParserServices.SourceTreeResolver;
ExpressionCollection arguments = new ExpressionCollection();
arguments.Add(qualifier);
method = GenericElementActivator.ActivateMemberIfNeeded(resolver, method, arguments, null, ArgumentsHelper.ResolveArgumentTypes(resolver, arguments)) as IMethodElement;
if (method == null)
{
return(false);
}
IParameterElement extensionParam = method.Parameters[0] as IParameterElement;
if (extensionParam == null)
{
return(false);
}
ITypeReferenceExpression typeRef = extensionParam.Type;
if (typeRef == null)
{
return(false);
}
ITypeElement type = typeRef.GetDeclaration() as ITypeElement;
if (type == null)
{
return(false);
}
IArrayTypeElement arrayType = callerType as IArrayTypeElement;
//if (arrayType != null)
//{
// return true;
//}
//else
return(ArgumentsHelper.HasParamConversion(resolver, extensionParam, callerType, qualifier, TypeConversionMode.ImplicitConversion));
}
private static bool IsExtensionMethod(IWithParameters declaration)
{
if (declaration == null || declaration.Parameters == null || declaration.Parameters.Count == 0)
{
return(false);
}
IMethodElement methodElement = declaration as IMethodElement;
if (methodElement == null)
{
return(false);
}
return(methodElement.IsExtensionMethod());
}
private static bool checkIfParametersAreTheSame(IMethodElement methodElement, IMethodElement currMethodElement)
{
if ((methodElement.Parameters.Count == 0) && (currMethodElement.Parameters.Count == 0))
return true;
bool found = false;
if (methodElement.Parameters.Count == currMethodElement.Parameters.Count)
{
for (int i = 0; i < methodElement.Parameters.Count && !found; i++)
{
if (methodElement.Parameters[i].Type.IsIdenticalTo(currMethodElement.Parameters[i].Type))
{
found = true;
}
}
}
return found;
}
private static bool checkIfParametersAreTheSame(IMethodElement methodElement, IMethodElement currMethodElement)
{
if ((methodElement.Parameters.Count == 0) && (currMethodElement.Parameters.Count == 0))
{
return(true);
}
bool found = false;
if (methodElement.Parameters.Count == currMethodElement.Parameters.Count)
{
for (int i = 0; i < methodElement.Parameters.Count && !found; i++)
{
if (methodElement.Parameters[i].Type.IsIdenticalTo(currMethodElement.Parameters[i].Type))
{
found = true;
}
}
}
return(found);
}
// event handlers...
private void cpAddReference_CheckAvailability(object sender, CheckContentAvailabilityEventArgs ea)
{
LanguageElement activeMethodRerence = GetActiveMethodReference(ea.Element);
if (activeMethodRerence == null)
{
return;
}
ITypeElement callerType;
Expression qualifier;
if (!IsValidReferenceAndQualifier(activeMethodRerence, out callerType, out qualifier))
{
return;
}
IEnumerable projectSymbols = GetProjectSymbols();
if (projectSymbols == null)
{
return;
}
string methodNameToFind = activeMethodRerence.Name;
IMethodElement extensionMethod = FindExtensionMethod(projectSymbols, methodNameToFind, callerType, qualifier);
if (extensionMethod == null || extensionMethod.ParentNamespace == null)
{
return;
}
_NamespaceOfExtensionMethod = extensionMethod.ParentNamespace.FullName;
ea.Available = true;
}
public static bool IsTestMethod(this IMethodElement currentMethod)
{
return currentMethod.Attributes.Cast<IAttributeElement>().Count(a => _testMethodAttributes.Contains(a.Name)) > 0;
}
private IAttributeElement GetExpectedExceptionAttribute(IMethodElement method)
{
return method.Attributes.OfType<IAttributeElement>().FirstOrDefault(attr => _expectedExceptionAttributes.Contains(attr.Name));
}
private static IElementReferenceExpression GetAssert(IMethodElement method)
{
return method.FindChildByName("Assert") as IElementReferenceExpression;
}
