public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (identifierExpression.TypeArguments != null && identifierExpression.TypeArguments.Count > 0)
{
if (resolver.CallingType != null)
{
foreach (var type in resolver.Dom.GetInheritanceTree(resolver.CallingType))
{
IMethod possibleMethod = type.Methods.Where(m => m.Name == identifierExpression.Identifier && m.TypeParameters.Count == identifierExpression.TypeArguments.Count && m.IsAccessibleFrom(resolver.Dom, resolver.CallingType, resolver.CallingMember, true)).FirstOrDefault();
if (possibleMethod != null)
{
MethodResolveResult methodResolveResult = new MethodResolveResult(possibleMethod);
methodResolveResult.CallingType = resolver.CallingType;
methodResolveResult.CallingMember = resolver.CallingMember;
identifierExpression.TypeArguments.ForEach(arg => methodResolveResult.AddGenericArgument(resolver.ResolveType(arg.ConvertToReturnType())));
methodResolveResult.ResolveExtensionMethods();
return(methodResolveResult);
}
}
}
TypeReference reference = new TypeReference(identifierExpression.Identifier);
reference.GenericTypes.AddRange(identifierExpression.TypeArguments);
ResolveResult result = CreateResult(reference);
result.StaticResolve = true;
return(result);
}
// Console.WriteLine ("visit id: " + identifierExpression.Identifier);
var res = resolver.ResolveIdentifier(this, identifierExpression.Identifier.TrimEnd('.'));
// Console.WriteLine ("result: " + res);
return(res);
}
public NRefactoryTemplateParameterDataProvider(TextEditorData editor, NRefactoryResolver resolver, IEnumerable <string> namespaces, ExpressionResult expressionResult, DomLocation loc)
{
// this.editor = editor;
ResolveResult plainResolveResult = resolver.Resolve(expressionResult, loc);
MethodResolveResult resolveResult = plainResolveResult as MethodResolveResult;
if (resolveResult != null)
{
foreach (IMethod method in resolveResult.Methods)
{
if (method.TypeParameters.Count > 0)
{
this.types.Add(method);
}
}
}
else
{
string typeName = expressionResult.Expression.Trim();
foreach (string ns in namespaces)
{
string prefix = ns + (ns.Length > 0 ? "." : "") + typeName + "`";
for (int i = 1; i < 99; i++)
{
IType possibleType = resolver.Dom.GetType(prefix + i);
if (possibleType != null)
{
this.types.Add(possibleType);
}
}
}
IType resolvedType = plainResolveResult != null?resolver.Dom.GetType(plainResolveResult.ResolvedType) : null;
if (resolvedType == null)
{
int idx = expressionResult.Expression.LastIndexOf(".");
if (idx < 0)
{
return;
}
typeName = expressionResult.Expression.Substring(idx + 1);
expressionResult.Expression = expressionResult.Expression.Substring(0, idx);
plainResolveResult = resolver.Resolve(expressionResult, loc);
resolvedType = resolver.Dom.GetType(plainResolveResult.ResolvedType);
}
if (resolvedType == null)
{
return;
}
foreach (IType innerType in resolvedType.InnerTypes)
{
this.types.Add(innerType);
}
}
}
public override bool IsValid(RefactoringOptions options)
{
INRefactoryASTProvider provider = options.GetASTProvider();
IResolver resolver = options.GetResolver();
if (provider == null || resolver == null)
{
return(false);
}
if (invoke == null)
{
invoke = GetInvocationExpression(options);
}
if (invoke == null)
{
return(false);
}
returnType = DomReturnType.Void;
modifiers = ICSharpCode.NRefactory.Ast.Modifiers.None;
resolvePosition = new DomLocation(options.Document.TextEditor.CursorLine, options.Document.TextEditor.CursorColumn);
ResolveResult resolveResult = resolver.Resolve(new ExpressionResult(provider.OutputNode(options.Dom, invoke)), resolvePosition);
if (resolveResult is MethodResolveResult)
{
MethodResolveResult mrr = (MethodResolveResult)resolveResult;
if (mrr.ExactMethodMatch)
{
return(false);
}
returnType = mrr.MostLikelyMethod.ReturnType;
modifiers = (ICSharpCode.NRefactory.Ast.Modifiers)mrr.MostLikelyMethod.Modifiers;
}
if (invoke.TargetObject is MemberReferenceExpression)
{
string callingObject = provider.OutputNode(options.Dom, ((MemberReferenceExpression)invoke.TargetObject).TargetObject);
resolveResult = resolver.Resolve(new ExpressionResult(callingObject), resolvePosition);
if (resolveResult == null || resolveResult.ResolvedType == null || resolveResult.CallingType == null)
{
return(false);
}
IType type = options.Dom.GetType(resolveResult.ResolvedType);
return(type != null && type.CompilationUnit != null && File.Exists(type.CompilationUnit.FileName) && RefactoringService.GetASTProvider(DesktopService.GetMimeTypeForUri(type.CompilationUnit.FileName)) != null);
}
return(invoke.TargetObject is IdentifierExpression);
}
public override object VisitInvocationExpression(InvocationExpression invokeExp, object data)
{
foreach (var tuple in searchedMembers)
{
var searchedMember = tuple.Item1;
if (searchedMember is IMethod)
{
IMethod method = (IMethod)searchedMember;
if (MightBeInvocation(invokeExp.TargetObject, method) && invokeExp.Arguments.Count == method.Parameters.Count)
{
ResolveResult resolveResult = resolver.ResolveExpression(invokeExp, ConvertLocation(invokeExp.StartLocation));
IMethod resolvedMethod = null;
if (resolveResult is MethodResolveResult)
{
MethodResolveResult mrr = (MethodResolveResult)resolveResult;
resolvedMethod = mrr.MostLikelyMethod;
}
else if (resolveResult is MemberResolveResult)
{
resolvedMethod = GetUnderlyingMember(((MemberResolveResult)resolveResult).ResolvedMember) as IMethod;
}
if (resolvedMethod != null)
{
if (resolvedMethod.FullName == method.FullName && resolvedMethod.TypeParameters.Count == method.TypeParameters.Count)
{
int line, column;
if (SearchText(SearchedMemberName, invokeExp.StartLocation.Line, invokeExp.StartLocation.Column, out line, out column))
{
AddUniqueReference(line, column, SearchedMemberName);
}
}
}
}
invokeExp.Arguments.ForEach(o => o.AcceptVisitor(this, data));
// for method searches the identifier expression of the invocation is NOT visited
// we've already checked the method.
return(true);
}
}
invokeExp.Arguments.ForEach(o => o.AcceptVisitor(this, data));
return(base.VisitInvocationExpression(invokeExp, data));
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
string invocation = "";
if (!invocationExpression.StartLocation.IsEmpty && !invocationExpression.EndLocation.IsEmpty)
{
invocation = this.data.Document.GetTextBetween(this.data.Document.LocationToOffset(invocationExpression.StartLocation.Line - 1, invocationExpression.StartLocation.Column - 1),
this.data.Document.LocationToOffset(invocationExpression.EndLocation.Line - 1, invocationExpression.EndLocation.Column - 1));
}
base.VisitInvocationExpression(invocationExpression, data);
MethodResolveResult mrr = resolver.Resolve(new ExpressionResult(invocation), new DomLocation(invocationExpression.StartLocation.Line - 1, invocationExpression.StartLocation.Column - 1)) as MethodResolveResult;
if (mrr != null && mrr.MostLikelyMethod != null && mrr.MostLikelyMethod is ExtensionMethod)
{
IMethod originalMethod = ((ExtensionMethod)mrr.MostLikelyMethod).OriginalMethod;
possibleTypeReferences.Add(new TypeReference(originalMethod.DeclaringType.Name));
}
return(null);
}
//bool staticResolve = false;
public NRefactoryParameterDataProvider(MonoDevelop.Ide.Gui.TextEditor editor, NRefactoryResolver resolver, MethodResolveResult resolveResult)
{
this.editor = editor;
//this.staticResolve = resolveResult.StaticResolve;
bool includeProtected = true;
HashSet <string> alreadyAdded = new HashSet <string> ();
foreach (IMethod method in resolveResult.Methods)
{
if (method.IsConstructor)
{
continue;
}
string str = ambience.GetString(method, OutputFlags.IncludeParameters);
if (alreadyAdded.Contains(str))
{
continue;
}
alreadyAdded.Add(str);
if (method.IsAccessibleFrom(resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
{
methods.Add(method);
}
}
methods.Sort(MethodComparer);
}
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);
}
}
}
}
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (invocationExpression == null)
{
return(null);
}
if (invocationDictionary.ContainsKey(invocationExpression))
{
return(invocationDictionary[invocationExpression]);
}
// add support for undocumented __makeref and __reftype keywords
if (invocationExpression.TargetObject is IdentifierExpression)
{
IdentifierExpression idExpr = invocationExpression.TargetObject as IdentifierExpression;
if (idExpr.Identifier == "__makeref")
{
return(CreateResult("System.TypedReference"));
}
if (idExpr.Identifier == "__reftype")
{
return(CreateResult("System.Type"));
}
}
ResolveResult targetResult = Resolve(invocationExpression.TargetObject);
if (targetResult is CombinedMethodResolveResult)
{
targetResult = ((CombinedMethodResolveResult)targetResult).MethodResolveResult;
}
targetResult.StaticResolve = false; // invocation result is never static
if (this.resolver.CallingType != null)
{
if (targetResult is ThisResolveResult)
{
targetResult = new MethodResolveResult(this.resolver.CallingType.Methods.Where(method => method.IsConstructor));
((MethodResolveResult)targetResult).Type = this.resolver.CallingType;
targetResult.CallingType = resolver.CallingType;
targetResult.CallingMember = resolver.CallingMember;
}
else if (targetResult is BaseResolveResult)
{
System.Collections.IEnumerable baseConstructors = null;
IType firstBaseType = null;
foreach (IReturnType bT in this.resolver.CallingType.BaseTypes)
{
IType resolvedBaseType = resolver.SearchType(bT);
if (firstBaseType == null && resolvedBaseType.ClassType != MonoDevelop.Projects.Dom.ClassType.Interface)
{
firstBaseType = resolvedBaseType;
}
foreach (IType baseType in resolver.Dom.GetInheritanceTree(resolvedBaseType))
{
if (baseType.ClassType == MonoDevelop.Projects.Dom.ClassType.Interface)
{
break;
}
baseConstructors = baseType.Methods.Where(method => method.IsConstructor);
goto bailOut;
}
}
bailOut:
if (baseConstructors == null)
{
if (firstBaseType != null)
{
// if there is a real base type without a .ctor a default .ctor for this type is generated.
DomMethod constructedConstructor;
constructedConstructor = new DomMethod();
constructedConstructor.Name = ".ctor";
constructedConstructor.MethodModifier = MethodModifier.IsConstructor;
constructedConstructor.DeclaringType = firstBaseType;
constructedConstructor.Modifiers = MonoDevelop.Projects.Dom.Modifiers.Public;
baseConstructors = new IMethod[] {
constructedConstructor
};
}
else
{
baseConstructors = resolver.SearchType(DomReturnType.Object).SearchMember(".ctor", true);
}
}
targetResult = new MethodResolveResult(baseConstructors);
((MethodResolveResult)targetResult).Type = this.resolver.CallingType;
targetResult.CallingType = resolver.CallingType;
targetResult.CallingMember = resolver.CallingMember;
}
}
MethodResolveResult methodResult = targetResult as MethodResolveResult;
if (methodResult != null)
{
methodResult.GetsInvoked = true;
// Console.WriteLine ("--------------------");
// Console.WriteLine ("i:" + methodResult.ResolvedType);
/* foreach (var arg in methodResult.GenericArguments) {
* methodResult.AddGenericArgument (arg);
* }*/
foreach (Expression arg in invocationExpression.Arguments)
{
var type = GetTypeSafe(arg);
methodResult.AddArgument(type);
}
//Console.WriteLine ("--------------------");
methodResult.ResolveExtensionMethods();
// Console.WriteLine ("i2:" + methodResult.ResolvedType);
/* MemberReferenceExpression mre = invocationExpression.TargetObject as MemberReferenceExpression;
* if (mre != null) {
* foreach (TypeReference typeReference in mre.TypeArguments) {
* methodResult.AddGenericArgument (new DomReturnType (String.IsNullOrEmpty (typeReference.SystemType) ? typeReference.Type : typeReference.SystemType));
* }
* }*/
// return CreateResult (methodResult.Methods [0].ReturnType);
}
invocationDictionary[invocationExpression] = targetResult;
return(targetResult);
}
ResolveResult ResolveMemberReference(ResolveResult result, MemberReferenceExpression memberReferenceExpression)
{
IType type = resolver.Dom.GetType(result.ResolvedType);
if (type == null)
{
return(null);
}
//Console.WriteLine ("Resolve member: " + memberReferenceExpression.MemberName + " on " + type);
List <IMember> member = new List <IMember> ();
List <IType> accessibleExtTypes = DomType.GetAccessibleExtensionTypes(resolver.Dom, resolver.Unit);
// Inheritance of extension methods is handled in DomType
foreach (IMethod method in type.GetExtensionMethods(accessibleExtTypes))
{
if (method.Name == memberReferenceExpression.MemberName)
{
member.Add(method);
}
}
bool includeProtected = true;
foreach (IType curType in resolver.Dom.GetInheritanceTree(type))
{
if (curType.ClassType == MonoDevelop.Projects.Dom.ClassType.Interface && type.ClassType != MonoDevelop.Projects.Dom.ClassType.Interface)
{
continue;
}
if (curType.IsAccessibleFrom(resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
{
foreach (IMember foundMember in curType.SearchMember(memberReferenceExpression.MemberName, true))
{
if (foundMember.IsExplicitDeclaration)
{
continue;
}
member.Add(foundMember);
}
}
}
if (member.Count > 0)
{
if (member[0] is IMethod)
{
bool isStatic = result.StaticResolve;
List <IMember> nonMethodMembers = new List <IMember> ();
List <string> errors = new List <string> ();
int typeParameterCount = 0;
if (memberReferenceExpression.TypeArguments != null)
{
typeParameterCount = memberReferenceExpression.TypeArguments.Count;
}
for (int i = 0; i < member.Count; i++)
{
IMethod method = member[i] as IMethod;
if (method == null)
{
nonMethodMembers.Add(member[i]);
}
if (!member[i].IsAccessibleFrom(resolver.Dom, type, resolver.CallingMember, includeProtected))
{
errors.Add(
MonoDevelop.Core.GettextCatalog.GetString("'{0}' is inaccessible due to its protection level.",
ambience.GetString(method, OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics)));
}
if (method != null && !method.IsFinalizer && (method.IsExtension || method.WasExtended) /* && method.IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, true)*/)
{
continue;
}
if ((member[i].IsStatic ^ isStatic) ||
/* !member[i].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected) || */
(method != null && (method.IsFinalizer || typeParameterCount > 0 && method.TypeParameters.Count != typeParameterCount)))
{
member.RemoveAt(i);
i--;
}
}
if (member.Count == 0)
{
return(null);
}
result = new MethodResolveResult(member);
((MethodResolveResult)result).Type = type;
result.CallingType = resolver.CallingType;
result.CallingMember = resolver.CallingMember;
result.ResolveErrors.AddRange(errors);
//result.StaticResolve = isStatic;
//result.UnresolvedType = result.ResolvedType = member[0].ReturnType;
foreach (TypeReference typeReference in memberReferenceExpression.TypeArguments)
{
((MethodResolveResult)result).AddGenericArgument(resolver.ResolveType(typeReference.ConvertToReturnType()));
}
((MethodResolveResult)result).ResolveExtensionMethods();
if (nonMethodMembers.Count > 0)
{
MemberResolveResult baseResult = (MemberResolveResult)CreateResult(nonMethodMembers[0].DeclaringType.CompilationUnit, nonMethodMembers[0].ReturnType);
baseResult.ResolvedMember = nonMethodMembers[0];
return(new CombinedMethodResolveResult(baseResult, (MethodResolveResult)result));
}
//System.Console.WriteLine(result + "/" + result.ResolvedType);
return(result);
}
if (member[0] is IType)
{
result = CreateResult(member[0].FullName);
result.StaticResolve = true;
}
else
{
result = CreateResult(member[0].DeclaringType.CompilationUnit, member[0].ReturnType);
((MemberResolveResult)result).ResolvedMember = member[0];
}
if (!member[0].IsAccessibleFrom(resolver.Dom, type, resolver.CallingMember, includeProtected))
{
result.ResolveErrors.Add(string.Format(MonoDevelop.Core.GettextCatalog.GetString("'{0}' is inaccessible due to it's protection level."), ambience.GetString(member[0], OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics)));
}
return(result);
}
return(new UnresolvedMemberResolveResult(result, memberReferenceExpression.MemberName)
{
CallingType = resolver.CallingType,
CallingMember = resolver.CallingMember
});
}
static string GetText(ResolveResult result, string expression, out bool debuggerCanShowValue)
{
debuggerCanShowValue = false;
if (result == null)
{
// when pressing control, show the expression even when it could not be resolved
return((Control.ModifierKeys == Keys.Control) ? "" : null);
}
if (result is MixedResolveResult)
{
return(GetText(((MixedResolveResult)result).PrimaryResult, expression, out debuggerCanShowValue));
}
IAmbience ambience = AmbienceService.CurrentAmbience;
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
if (result is MemberResolveResult)
{
return(GetMemberText(ambience, ((MemberResolveResult)result).ResolvedMember, expression, out debuggerCanShowValue));
}
else if (result is LocalResolveResult)
{
LocalResolveResult rr = (LocalResolveResult)result;
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedNames
| ConversionFlags.ShowReturnType
| ConversionFlags.QualifiedNamesOnlyForReturnTypes;
StringBuilder b = new StringBuilder();
if (rr.IsParameter)
{
b.Append("parameter ");
}
else
{
b.Append("local variable ");
}
b.Append(ambience.Convert(rr.Field));
if (currentDebugger != null)
{
string currentValue = currentDebugger.GetValueAsString(rr.Field.Name);
if (currentValue != null)
{
debuggerCanShowValue = true;
b.Append(" = ");
b.Append(currentValue);
}
}
return(b.ToString());
}
else if (result is NamespaceResolveResult)
{
return("namespace " + ((NamespaceResolveResult)result).Name);
}
else if (result is TypeResolveResult)
{
IClass c = ((TypeResolveResult)result).ResolvedClass;
if (c != null)
{
return(GetMemberText(ambience, c, expression, out debuggerCanShowValue));
}
else
{
return(ambience.Convert(result.ResolvedType));
}
}
else if (result is MethodResolveResult)
{
MethodResolveResult mrr = result as MethodResolveResult;
IMethod m = mrr.GetMethodIfSingleOverload();
if (m != null)
{
return(GetMemberText(ambience, m, expression, out debuggerCanShowValue));
}
else
{
return("Overload of " + ambience.Convert(mrr.ContainingType) + "." + mrr.Name);
}
}
else
{
if (Control.ModifierKeys == Keys.Control)
{
if (result.ResolvedType != null)
{
return("expression of type " + ambience.Convert(result.ResolvedType));
}
else
{
return("ResolveResult without ResolvedType");
}
}
else
{
return(null);
}
}
}
public ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier)
{
ResolveResult result = null;
if (resultTable.TryGetValue(identifier, out result))
{
return(result);
}
resultTable[identifier] = result;
// Console.WriteLine (lookupVariableLine);
foreach (KeyValuePair <string, List <LocalLookupVariable> > pair in this.lookupTableVisitor.Variables)
{
if (identifier == pair.Key)
{
LocalLookupVariable var = null;
// Console.WriteLine ("--- RP:" + this.resolvePosition + "/" + pair.Value.Count);
foreach (LocalLookupVariable v2 in pair.Value)
{
DomLocation varStartPos = new DomLocation(lookupVariableLine + v2.StartPos.Line, v2.StartPos.Column - 1);
DomLocation varEndPos = new DomLocation(lookupVariableLine + v2.EndPos.Line, v2.EndPos.Column - 1);
// Console.WriteLine (v2.Name + ":" + varStartPos + " <> " + varEndPos + " resolve position:" + this.resolvePosition);
if (varStartPos > this.resolvePosition || (!v2.EndPos.IsEmpty && varEndPos < this.resolvePosition))
{
continue;
}
var = v2;
}
// Console.WriteLine ("var:" + var);
if (var == null)
{
continue;
}
IReturnType varType = null;
IReturnType varTypeUnresolved = null;
if (var.IsQueryContinuation)
{
QueryExpression query = var.Initializer as QueryExpression;
QueryExpressionGroupClause grouBy = query.SelectOrGroupClause as QueryExpressionGroupClause;
DomLocation old = resolvePosition;
try {
resolvePosition = new DomLocation(lookupVariableLine + grouBy.Projection.StartLocation.Line,
grouBy.Projection.StartLocation.Column);
ResolveResult initializerResolve = visitor.Resolve(grouBy.Projection);
ResolveResult groupByResolve = visitor.Resolve(grouBy.GroupBy);
DomReturnType resolved = new DomReturnType(dom.GetType("System.Linq.IGrouping", new IReturnType [] {
DomType.GetComponentType(dom, initializerResolve.ResolvedType), groupByResolve.ResolvedType
}));
varTypeUnresolved = varType = resolved;
} finally {
resolvePosition = old;
}
}
else if ((var.TypeRef == null || var.TypeRef.Type == "var" || var.TypeRef.IsNull))
{
if (var.ParentLambdaExpression != null)
{
ResolveResult lambdaResolve = ResolveLambda(visitor, var.ParentLambdaExpression);
if (lambdaResolve != null)
{
varType = lambdaResolve.ResolvedType;
varTypeUnresolved = lambdaResolve.UnresolvedType;
IType type = Dom.GetType(varType);
if (type != null && type.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate)
{
IMethod invocationMethod = type.Methods.First();
if (invocationMethod.Parameters.Count > 0)
{
varType = varTypeUnresolved = invocationMethod.Parameters[0].ReturnType;
}
}
}
else
{
varType = varTypeUnresolved = DomReturnType.Void;
}
}
if (var.Initializer != null)
{
ResolveResult initializerResolve = visitor.Resolve(var.Initializer);
// Console.WriteLine ("initializer : "+ var.Initializer + " result:" + initializerResolve);
varType = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.ResolvedType) : initializerResolve.ResolvedType;
varTypeUnresolved = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.UnresolvedType) : initializerResolve.UnresolvedType;
// Console.WriteLine ("resolved type:" + initializerResolve.ResolvedType + " is loop : " + var.IsLoopVariable);
// Console.WriteLine (varType);
// Console.WriteLine ("----------");
}
}
else
{
varTypeUnresolved = varType = ConvertTypeReference(var.TypeRef);
}
varType = ResolveType(varType);
result = new LocalVariableResolveResult(
new LocalVariable(CallingMember, identifier, varType,
new DomRegion(lookupVariableLine + var.StartPos.Line, var.StartPos.Column,
lookupVariableLine + var.StartPos.Line, var.EndPos.Column)),
var.IsLoopVariable);
result.ResolvedType = varType;
result.UnresolvedType = varTypeUnresolved;
goto end;
}
}
if (this.callingMember != null)
{
// special handling of property or field return types, they can have the same name as the return type
// ex.: MyType MyType { get; set; } Type1 Type1;
if ((callingMember is IProperty || callingMember is IField) && identifier == callingMember.Name)
{
int pos = editor.GetPositionFromLineColumn(resolvePosition.Line, resolvePosition.Column);
while (pos < editor.TextLength && !Char.IsWhiteSpace(editor.GetCharAt(pos)))
{
pos++;
}
while (pos < editor.TextLength && Char.IsWhiteSpace(editor.GetCharAt(pos)))
{
pos++;
}
StringBuilder memberName = new StringBuilder();
while (pos < editor.TextLength && (Char.IsLetterOrDigit(editor.GetCharAt(pos)) || editor.GetCharAt(pos) == '_'))
{
memberName.Append(editor.GetCharAt(pos));
pos++;
}
//Console.WriteLine ("id: '" + identifier + "' : '" + memberName.ToString () +"'" + (memberName.ToString () == identifier));
if (memberName.ToString() == identifier)
{
result = visitor.CreateResult(callingMember.ReturnType);
goto end;
}
}
if (identifier == "value" && this.callingMember is IProperty)
{
result = new MemberResolveResult(this.callingMember);
result.UnresolvedType = ((IProperty)this.callingMember).ReturnType;
result.ResolvedType = ResolveType(((IProperty)this.callingMember).ReturnType);
goto end;
}
if (this.callingMember is IMethod || this.callingMember is IProperty)
{
ReadOnlyCollection <IParameter> prms = this.callingMember is IMethod
? ((IMethod)this.callingMember).Parameters
: ((IProperty)this.callingMember).Parameters;
if (prms != null)
{
foreach (IParameter para in prms)
{
if (para.Name == identifier)
{
result = new ParameterResolveResult(para);
result.UnresolvedType = para.ReturnType;
result.ResolvedType = ResolveType(para.ReturnType);
goto end;
}
}
}
}
}
IType searchedType = SearchType(identifier);
if (this.callingType != null && dom != null)
{
List <IMember> members = new List <IMember> ();
foreach (IType type in dom.GetInheritanceTree(callingType))
{
members.AddRange(type.SearchMember(identifier, true));
}
bool includeProtected = true;
// filter members
if (this.CallingMember != null)
{
for (int i = 0; i < members.Count; i++)
{
if (this.CallingMember.IsStatic && !members[i].IsStatic ||
!members[i].IsAccessibleFrom(dom, callingType, this.CallingMember, includeProtected))
{
members.RemoveAt(i);
i--;
continue;
}
}
}
if (members.Count > 0)
{
if (members[0] is IMethod)
{
result = new MethodResolveResult(members);
if (CallingMember != null)
{
result.StaticResolve = CallingMember.IsStatic;
}
}
else if (members[0] is IType)
{
result = new MemberResolveResult(null, true);
result.UnresolvedType = result.ResolvedType = new DomReturnType((IType)members[0]);
goto end;
}
else
{
result = new MemberResolveResult(members[0]);
}
result.UnresolvedType = members[0].ReturnType;
result.ResolvedType = ResolveType(members[0].ReturnType);
if (members[0] is IProperty && searchedType != null && result.ResolvedType.FullName == searchedType.FullName)
{
result = new AggregatedResolveResult(result, new MemberResolveResult(null, true)
{
UnresolvedType = new DomReturnType(searchedType),
ResolvedType = new DomReturnType(searchedType)
});
}
goto end;
}
}
if (searchedType != null)
{
result = new MemberResolveResult(null, true);
result.UnresolvedType = result.ResolvedType = new DomReturnType(searchedType);
goto end;
}
if (dom.NamespaceExists(identifier, true))
{
result = new NamespaceResolveResult(identifier);
goto end;
}
if (unit != null && unit.Usings != null)
{
foreach (IUsing u in unit.Usings)
{
if (u.IsFromNamespace && u.Region.Contains(resolvePosition))
{
foreach (string ns in u.Namespaces)
{
if (dom.NamespaceExists(ns + "." + identifier, true))
{
result = new NamespaceResolveResult(ns + "." + identifier);
goto end;
}
}
}
foreach (KeyValuePair <string, IReturnType> alias in u.Aliases)
{
if (alias.Key == identifier || alias.Key + ".?" == identifier)
{
result = new NamespaceResolveResult(alias.Value.FullName);
goto end;
}
}
}
}
end:
if (result != null)
{
result.CallingType = CallingType;
result.CallingMember = CallingMember;
}
resultTable[identifier] = result;
return(result);
}
internal ResolveResult ResolveLambda(ResolveVisitor visitor, Expression lambdaExpression)
{
if (expressions.Contains(lambdaExpression))
{
return(null);
}
expressions.Add(lambdaExpression);
if (lambdaExpression.Parent is LambdaExpression)
{
return(ResolveLambda(visitor, lambdaExpression.Parent as Expression));
}
if (lambdaExpression.Parent is ParenthesizedExpression)
{
return(ResolveLambda(visitor, lambdaExpression.Parent as Expression));
}
if (lambdaExpression.Parent is AssignmentExpression)
{
return(visitor.Resolve(((AssignmentExpression)lambdaExpression.Parent).Left));
}
if (lambdaExpression.Parent is CastExpression)
{
return(visitor.Resolve(((CastExpression)lambdaExpression.Parent)));
}
if (lambdaExpression.Parent is VariableDeclaration)
{
VariableDeclaration varDec = (VariableDeclaration)lambdaExpression.Parent;
return(resolver.GetFunctionParameterType(resolver.ResolveIdentifier(visitor, varDec.Name)));
}
if (lambdaExpression.Parent is InvocationExpression)
{
LambdaExpression lambda = (LambdaExpression)lambdaExpression;
ResolveResult lambdaReturnType = null;
if (!lambda.ExpressionBody.IsNull)
{
DomLocation old = resolver.resolvePosition;
try {
resolver.resolvePosition = new DomLocation((resolver.CallingMember != null ? resolver.CallingMember.Location.Line : 0) +
lambda.ExpressionBody.StartLocation.Line - 2,
lambda.ExpressionBody.StartLocation.Column - 1);
lambdaReturnType = visitor.Resolve(lambda.ExpressionBody);
} finally {
resolver.resolvePosition = old;
}
}
InvocationExpression invocation = (InvocationExpression)lambdaExpression.Parent;
MethodResolveResult result = visitor.Resolve(invocation.TargetObject) as MethodResolveResult;
if (result == null)
{
MonoDevelop.Core.LoggingService.LogWarning("No compatible method found :" + invocation.TargetObject);
return(null);
}
result.ResolveExtensionMethods();
for (int i = 0; i < invocation.Arguments.Count; i++)
{
if (invocation.Arguments[i] == lambdaExpression && i < result.MostLikelyMethod.Parameters.Count)
{
IParameter parameter = result.MostLikelyMethod.Parameters[i];
IReturnType returnType = parameter.ReturnType;
IType type = resolver.Dom.GetType(returnType);
bool isResolved = false;
if (type != null && type.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate)
{
IMethod invocationMethod = type.Methods.First();
if (invocationMethod.Parameters.Count > 0)
{
if (lambdaReturnType == null || lambdaReturnType.ResolvedType == null || string.IsNullOrEmpty(lambdaReturnType.ResolvedType.FullName))
{
returnType = invocationMethod.Parameters[System.Math.Min(i, invocationMethod.Parameters.Count - 1)].ReturnType;
}
else
{
returnType = (IReturnType) new TypeReplaceVisitor(invocationMethod.ReturnType, lambdaReturnType.ResolvedType).Visit(returnType, null);
}
isResolved = true;
}
}
if (!isResolved)
{
while (returnType.GenericArguments.Count > 0)
{
returnType = returnType.GenericArguments[0];
}
}
string invariantString = returnType.ToInvariantString();
if (returnTypeDictionary.ContainsKey(invariantString))
{
return(returnTypeDictionary[invariantString]);
}
ResolveResult createdResult = visitor.CreateResult(returnType);
// if (!(returnType.Type is AnonymousType))
returnTypeDictionary[invariantString] = createdResult;
return(createdResult);
}
}
if (lambdaReturnType != null && !string.IsNullOrEmpty(lambdaReturnType.ResolvedType.FullName))
{
return(lambdaReturnType);
}
foreach (Expression arg in invocation.Arguments)
{
var argType = arg is LambdaExpression ? DomReturnType.Void : visitor.GetTypeSafe(arg);
result.AddArgument(argType);
}
result.ResolveExtensionMethods();
//Console.WriteLine ("maybe method:" + result.MostLikelyMethod);
for (int i = 0; i < invocation.Arguments.Count; i++)
{
if (invocation.Arguments [i] == lambdaExpression && i < result.MostLikelyMethod.Parameters.Count)
{
IParameter parameterType = result.MostLikelyMethod.Parameters [i];
//Console.WriteLine (i + " par: " + parameterType);
if (parameterType.ReturnType.Name == "Func" && parameterType.ReturnType.GenericArguments.Count > 0)
{
return(visitor.CreateResult(parameterType.ReturnType.GenericArguments[0]));
}
}
}
return(result);
}
if (lambdaExpression.Parent is ObjectCreateExpression)
{
ObjectCreateExpression objectCreateExpression = (ObjectCreateExpression)lambdaExpression.Parent;
int index = objectCreateExpression.Parameters.IndexOf(lambdaExpression);
if (index < 0)
{
return(null);
}
MemberResolveResult resolvedCreateExpression = visitor.Resolve(objectCreateExpression) as MemberResolveResult;
if (resolvedCreateExpression != null)
{
IMethod method = resolvedCreateExpression.ResolvedMember as IMethod;
if (method != null && index < method.Parameters.Count)
{
return(new ParameterResolveResult(method.Parameters[index]));
}
else
{
return(null);
}
}
}
return(null);
}
public string CreateTooltip(ProjectDom dom, ICompilationUnit unit, MonoDevelop.Projects.Dom.ResolveResult result, string errorInformations, Ambience ambience, Gdk.ModifierType modifierState)
{
OutputSettings settings = new OutputSettings(OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
if ((Gdk.ModifierType.ShiftMask & modifierState) == Gdk.ModifierType.ShiftMask)
{
settings.EmitNameCallback = delegate(INode domVisitable, ref string outString) {
// crop used namespaces.
if (unit != null)
{
int len = 0;
foreach (IUsing u in unit.Usings)
{
foreach (string ns in u.Namespaces)
{
if (outString.StartsWith(ns + "."))
{
len = Math.Max(len, ns.Length + 1);
}
}
}
string newName = outString.Substring(len);
int count = 0;
// check if there is a name clash.
if (dom.GetType(newName) != null)
{
count++;
}
foreach (IUsing u in unit.Usings)
{
foreach (string ns in u.Namespaces)
{
if (dom.GetType(ns + "." + newName) != null)
{
count++;
}
}
}
if (len > 0 && count == 1)
{
outString = newName;
}
}
};
}
// Approximate value for usual case
StringBuilder s = new StringBuilder(150);
string doc = null;
if (result != null)
{
if (result is AggregatedResolveResult)
{
result = ((AggregatedResolveResult)result).PrimaryResult;
}
if (result is ParameterResolveResult)
{
s.Append("<small><i>");
s.Append(paramStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(((ParameterResolveResult)result).Parameter, settings));
}
else if (result is LocalVariableResolveResult)
{
s.Append("<small><i>");
s.Append(localStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(((LocalVariableResolveResult)result).ResolvedType, settings));
s.Append(" ");
s.Append(((LocalVariableResolveResult)result).LocalVariable.Name);
}
else if (result is UnresolvedMemberResolveResult)
{
s.Append(String.Format(GettextCatalog.GetString("Unresolved member '{0}'"), ((UnresolvedMemberResolveResult)result).MemberName));
}
else if (result is MethodResolveResult)
{
MethodResolveResult mrr = (MethodResolveResult)result;
s.Append("<small><i>");
s.Append(methodStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(mrr.MostLikelyMethod, settings));
if (mrr.Methods.Count > 1)
{
int overloadCount = mrr.Methods.Count - 1;
s.Append(string.Format(GettextCatalog.GetPluralString(" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
}
doc = AmbienceService.GetDocumentationSummary(((MethodResolveResult)result).MostLikelyMethod);
}
else if (result is MemberResolveResult)
{
IMember member = ((MemberResolveResult)result).ResolvedMember;
if (member == null)
{
IReturnType returnType = ((MemberResolveResult)result).ResolvedType;
if (returnType != null)
{
IType type = dom.GetType(returnType);
if (type != null)
{
s.Append("<small><i>");
s.Append(typeStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(type, settings));
doc = AmbienceService.GetDocumentationSummary(type);
}
}
}
else
{
if (member is IField)
{
s.Append("<small><i>");
s.Append(fieldStr);
s.Append("</i></small>\n");
}
else if (member is IProperty)
{
s.Append("<small><i>");
s.Append(propertyStr);
s.Append("</i></small>\n");
}
s.Append(ambience.GetString(member, settings));
doc = AmbienceService.GetDocumentationSummary(member);
}
}
else if (result is NamespaceResolveResult)
{
s.Append("<small><i>");
s.Append(namespaceStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(new Namespace(((NamespaceResolveResult)result).Namespace), settings));
}
else
{
s.Append(ambience.GetString(result.ResolvedType, settings));
}
if (!string.IsNullOrEmpty(doc))
{
s.Append("\n<small>");
s.Append(AmbienceService.GetDocumentationMarkup("<summary>" + doc + "</summary>"));
s.Append("</small>");
}
}
if (!string.IsNullOrEmpty(errorInformations))
{
if (s.Length != 0)
{
s.Append("\n\n");
}
s.Append("<small>");
s.Append(errorInformations);
s.Append("</small>");
}
return(s.ToString());
}
