ResolveResult ResolveAttribute(Expression expr)
{
string attributeName = GetAttributeName(expr);
IClass c = GetAttribute(attributeName);
if (c != null)
{
return(new TypeResolveResult(callingClass, callingMember, c));
}
else if (expr is InvocationExpression)
{
InvocationExpression ie = (InvocationExpression)expr;
attributeName = GetAttributeName(ie.TargetObject);
c = GetAttribute(attributeName);
if (c != null)
{
List <IMethod> ctors = new List <IMethod>();
foreach (IMethod m in c.Methods)
{
if (m.IsConstructor && !m.IsStatic)
{
ctors.Add(m);
}
}
TypeVisitor typeVisitor = new TypeVisitor(this);
return(CreateMemberResolveResult(typeVisitor.FindOverload(ctors, null, ie.Arguments, null)));
}
}
return(null);
}
public ResolveResult ResolveInternal(Expression expr, ExpressionContext context)
{
TypeVisitor typeVisitor = new TypeVisitor(this);
IReturnType type;
if (expr is PrimitiveExpression)
{
if (((PrimitiveExpression)expr).Value is int)
{
return(new IntegerLiteralResolveResult(callingClass, callingMember, projectContent.SystemTypes.Int32));
}
}
else if (expr is InvocationExpression)
{
IMethodOrProperty method = typeVisitor.GetMethod(expr as InvocationExpression);
if (method != null)
{
return(CreateMemberResolveResult(method));
}
else
{
// InvocationExpression can also be a delegate/event call
ResolveResult invocationTarget = ResolveInternal((expr as InvocationExpression).TargetObject, ExpressionContext.Default);
if (invocationTarget == null)
{
return(null);
}
type = invocationTarget.ResolvedType;
if (type == null)
{
return(null);
}
IClass c = type.GetUnderlyingClass();
if (c == null || c.ClassType != ClassType.Delegate)
{
return(null);
}
// We don't want to show "System.EventHandler.Invoke" in the tooltip
// of "EventCall(this, EventArgs.Empty)", we just show the event/delegate for now
// but for DelegateCall(params).* completion, we use the delegate's
// return type instead of the delegate type itself
method = c.Methods.Find(delegate(IMethod innerMethod) { return(innerMethod.Name == "Invoke"); });
if (method != null)
{
invocationTarget.ResolvedType = method.ReturnType;
}
return(invocationTarget);
}
}
else if (expr is IndexerExpression)
{
return(CreateMemberResolveResult(typeVisitor.GetIndexer(expr as IndexerExpression)));
}
else if (expr is FieldReferenceExpression)
{
FieldReferenceExpression fieldReferenceExpression = (FieldReferenceExpression)expr;
if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName.Length == 0)
{
// NRefactory creates this "dummy" fieldReferenceExpression when it should
// parse a primitive type name (int, short; Integer, Decimal)
if (fieldReferenceExpression.TargetObject is TypeReferenceExpression)
{
type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference, this);
if (type != null)
{
return(new TypeResolveResult(callingClass, callingMember, type));
}
}
}
type = fieldReferenceExpression.TargetObject.AcceptVisitor(typeVisitor, null) as IReturnType;
if (type != null)
{
ResolveResult result = ResolveMemberReferenceExpression(type, fieldReferenceExpression);
if (result != null)
{
return(result);
}
}
}
else if (expr is IdentifierExpression)
{
ResolveResult result = ResolveIdentifier(((IdentifierExpression)expr).Identifier, context);
if (result != null)
{
return(result);
}
}
else if (expr is TypeReferenceExpression)
{
type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)expr).TypeReference, this);
if (type != null)
{
if (type is TypeVisitor.NamespaceReturnType)
{
return(new NamespaceResolveResult(callingClass, callingMember, type.FullyQualifiedName));
}
IClass c = type.GetUnderlyingClass();
if (c != null)
{
return(new TypeResolveResult(callingClass, callingMember, type, c));
}
}
return(null);
}
type = expr.AcceptVisitor(typeVisitor, null) as IReturnType;
if (type == null || type.FullyQualifiedName == "")
{
return(null);
}
if (expr is ObjectCreateExpression)
{
List <IMethod> constructors = new List <IMethod>();
foreach (IMethod m in type.GetMethods())
{
if (m.IsConstructor && !m.IsStatic)
{
constructors.Add(m);
}
}
if (constructors.Count == 0)
{
// Class has no constructors -> create default constructor
IClass c = type.GetUnderlyingClass();
if (c != null)
{
return(CreateMemberResolveResult(Constructor.CreateDefault(c)));
}
}
IReturnType[] typeParameters = null;
if (type.IsConstructedReturnType)
{
typeParameters = new IReturnType[type.CastToConstructedReturnType().TypeArguments.Count];
type.CastToConstructedReturnType().TypeArguments.CopyTo(typeParameters, 0);
}
ResolveResult rr = CreateMemberResolveResult(typeVisitor.FindOverload(constructors, typeParameters, ((ObjectCreateExpression)expr).Parameters, null));
if (rr != null)
{
rr.ResolvedType = type;
}
return(rr);
}
return(new ResolveResult(callingClass, callingMember, type));
}
