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); } } } } }