internal ResolveResult ResolveConstructorOverload(IReturnType rt, List <Expression> arguments)
{
if (rt == null)
{
return(null);
}
List <IMethod> methods = rt.GetMethods().Where(m => m.IsConstructor && !m.IsStatic).ToList();
IReturnType[] argumentTypes = arguments.Select <Expression, IReturnType>(ResolveType).ToArray();
bool resultIsAcceptable;
IMethod result = MemberLookupHelper.FindOverload(methods, argumentTypes, out resultIsAcceptable);
if (result == null)
{
IClass c = rt.GetUnderlyingClass();
if (c != null)
{
result = Constructor.CreateDefault(c);
}
}
ResolveResult rr = CreateMemberResolveResult(result);
if (rr != null)
{
rr.ResolvedType = rt;
}
return(rr);
}
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));
}
protected virtual void SetupDataProvider(string fileName, IDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn)
{
bool constructorInsight = false;
if (expressionResult.Context.IsAttributeContext)
{
constructorInsight = true;
}
else if (expressionResult.Context.IsObjectCreation)
{
constructorInsight = true;
expressionResult.Context = ExpressionContext.Type;
}
ResolveResult results = ParserService.Resolve(expressionResult, caretLineNumber, caretColumn, fileName, document.TextContent);
LanguageProperties language = ParserService.CurrentProjectContent.Language;
TypeResolveResult trr = results as TypeResolveResult;
if (trr == null && language.AllowObjectConstructionOutsideContext)
{
if (results is MixedResolveResult)
{
trr = (results as MixedResolveResult).TypeResult;
}
}
if (trr != null && !constructorInsight)
{
if (language.AllowObjectConstructionOutsideContext)
{
constructorInsight = true;
}
}
if (constructorInsight)
{
if (trr == null)
{
return;
}
foreach (IMethod method in trr.ResolvedType.GetMethods())
{
if (method.IsConstructor && !method.IsStatic)
{
methods.Add(method);
}
}
if (methods.Count == 0 && trr.ResolvedClass != null && !trr.ResolvedClass.IsAbstract && !trr.ResolvedClass.IsStatic)
{
// add default constructor
methods.Add(Constructor.CreateDefault(trr.ResolvedClass));
}
}
else
{
MethodResolveResult result = results as MethodResolveResult;
if (result == null)
{
return;
}
bool classIsInInheritanceTree = false;
if (result.CallingClass != null)
{
classIsInInheritanceTree = result.CallingClass.IsTypeInInheritanceTree(result.ContainingType.GetUnderlyingClass());
}
foreach (IMethod method in result.ContainingType.GetMethods())
{
if (language.NameComparer.Equals(method.Name, result.Name))
{
if (method.IsAccessible(result.CallingClass, classIsInInheritanceTree))
{
methods.Add(method);
}
}
}
if (methods.Count == 0 && result.CallingClass != null && language.SupportsExtensionMethods)
{
ArrayList list = new ArrayList();
ResolveResult.AddExtensions(language, list, result.CallingClass, result.ContainingType);
foreach (IMethodOrProperty mp in list)
{
if (language.NameComparer.Equals(mp.Name, result.Name) && mp is IMethod)
{
IMethod m = (IMethod)mp.Clone();
m.Parameters.RemoveAt(0);
methods.Add(m);
}
}
}
}
}
