public CombinedMethodResolveResult(MemberResolveResult baseResolveResult, MethodResolveResult methodResolveResult)
{
BaseResolveResult = baseResolveResult;
MethodResolveResult = methodResolveResult;
CallingType = baseResolveResult.CallingType;
CallingMember = baseResolveResult.CallingMember;
StaticResolve = baseResolveResult.StaticResolve;
ResolvedMember = baseResolveResult.ResolvedMember;
ResolvedExpression = baseResolveResult.ResolvedExpression;
}
public NRefactoryParameterDataProvider (TextEditorData editor, NRefactoryResolver resolver, MethodResolveResult resolveResult)
{
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 | OutputFlags.GeneralizeGenerics | OutputFlags.IncludeGenerics);
if (alreadyAdded.Contains (str))
continue;
alreadyAdded.Add (str);
if (method.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
methods.Add (method);
}
methods.Sort (MethodComparer);
}
public CombinedMethodResolveResult (MemberResolveResult baseResolveResult, MethodResolveResult methodResolveResult)
{
BaseResolveResult = baseResolveResult;
MethodResolveResult = methodResolveResult;
CallingType = baseResolveResult.CallingType;
CallingMember = baseResolveResult.CallingMember;
StaticResolve = baseResolveResult.StaticResolve;
ResolvedMember = baseResolveResult.ResolvedMember;
ResolvedExpression = baseResolveResult.ResolvedExpression;
}
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;
if (result is BaseResolveResult && foundMember.IsAbstract)
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
};
}
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 ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier)
{
ResolveResult result = null;
if (resultTable.TryGetValue (identifier, out result))
return result;
resultTable[identifier] = result;
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);
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;
} 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);
}
// Console.WriteLine ("-----");
// Console.WriteLine (varType);
varType = ResolveType (varType);
result = new LocalVariableResolveResult (
new LocalVariable (CallingMember, identifier, varType,
new DomRegion (lookupVariableLine + var.StartPos.Line - 1, var.StartPos.Column - 1,
lookupVariableLine + var.StartPos.Line - 1, var.EndPos.Column - 1)),
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 = dom.SearchType (new SearchTypeRequest (unit, this.CallingType, 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;
}
