public override object VisitQueryExpression(QueryExpression queryExpression, object data)
{
if (this.queryExpression != null) // prevent endloss loop: var n = from n select n; n.$ (doesn't make sense, but you can type this)
{
return(null);
}
this.queryExpression = queryExpression;
IReturnType type = null;
QueryExpressionSelectClause selectClause = queryExpression.SelectOrGroupClause as QueryExpressionSelectClause;
if (selectClause != null)
{
InvocationExpression selectInvocation = new InvocationExpression(new MemberReferenceExpression(queryExpression.FromClause.InExpression, "Select"));
LambdaExpression selectLambdaExpr = new LambdaExpression();
selectLambdaExpr.Parent = selectInvocation;
selectLambdaExpr.Parameters.Add(new ParameterDeclarationExpression(null, "par"));
selectLambdaExpr.ExpressionBody = selectClause.Projection;
TypeReference typeRef = new TypeReference("System.Func");
typeRef.GenericTypes.Add(TypeReference.Null);
ResolveResult result = resolver.ResolveExpression(selectLambdaExpr, resolver.ResolvePosition, false);
typeRef.GenericTypes.Add(NRefactoryResolver.ConvertToTypeReference(result.ResolvedType));
ObjectCreateExpression createExpression = new ObjectCreateExpression(typeRef, new List <Expression> (new Expression [] {
null,
selectLambdaExpr
}));
selectInvocation.Arguments.Add(createExpression);
return(CreateResult(ResolveType(selectInvocation)));
}
QueryExpressionGroupClause groupClause = queryExpression.SelectOrGroupClause as QueryExpressionGroupClause;
if (groupClause != null)
{
InvocationExpression groupInvocation = new InvocationExpression(new MemberReferenceExpression(queryExpression.FromClause.InExpression, "GroupBy"));
LambdaExpression keyLambdaExpr = new LambdaExpression();
keyLambdaExpr.Parent = groupInvocation;
keyLambdaExpr.Parameters.Add(new ParameterDeclarationExpression(null, "par"));
keyLambdaExpr.ExpressionBody = groupClause.GroupBy;
groupInvocation.Arguments.Add(keyLambdaExpr);
LambdaExpression elementLambdaExpr = new LambdaExpression();
elementLambdaExpr.Parent = groupInvocation;
elementLambdaExpr.Parameters.Add(new ParameterDeclarationExpression(null, "par"));
elementLambdaExpr.ExpressionBody = groupClause.Projection;
groupInvocation.Arguments.Add(elementLambdaExpr);
return(CreateResult(ResolveType(groupInvocation)));
}
if (type != null)
{
return(CreateResult(new DomReturnType("System.Collections.Generic.IEnumerable", false, new List <IReturnType> (new IReturnType[] { type }))));
}
return(null);
}
internal ResolveResult CreateResult(TypeReference typeReference)
{
return(CreateResult(NRefactoryResolver.ConvertTypeReference(typeReference)));
}
public override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
{
if (memberReferenceExpression == null)
{
return(null);
}
ResolveResult result;
if (String.IsNullOrEmpty(memberReferenceExpression.MemberName))
{
if (memberReferenceExpression.TargetObject is TypeReferenceExpression)
{
result = CreateResult(((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
result.StaticResolve = true;
return(result);
}
// if (memberReferenceExpression.TargetObject is ThisReferenceExpression) {
// result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
// result.StaticResolve = true;
// return result;
// }
// return memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
}
result = memberReferenceExpression.TargetObject.AcceptVisitor(this, data) as ResolveResult;
NamespaceResolveResult namespaceResult = result as NamespaceResolveResult;
if (namespaceResult != null)
{
if (String.IsNullOrEmpty(memberReferenceExpression.MemberName))
{
return(namespaceResult);
}
string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName;
if (resolver.Dom.NamespaceExists(fullName, true))
{
return(new NamespaceResolveResult(fullName));
}
DomReturnType searchType = new DomReturnType(fullName);
if (memberReferenceExpression.TypeArguments != null)
{
foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments)
{
searchType.AddTypeParameter(NRefactoryResolver.ConvertTypeReference(typeRef));
}
}
IType type = resolver.Dom.GetType(searchType);
if (type != null)
{
result = CreateResult(this.resolver.Unit, new DomReturnType(type));
result.StaticResolve = true;
return(result);
}
return(null);
}
if (result != null && result.ResolvedType != null)
{
foreach (ResolveResult innerResult in result.ResolveResults)
{
ResolveResult resolvedResult = ResolveMemberReference(innerResult, memberReferenceExpression);
if (resolvedResult != null)
{
return(resolvedResult);
}
}
}
else
{
if (result != null)
{
MonoDevelop.Core.LoggingService.LogWarning("Couldn't resolve type " + result.ResolvedType);
}
}
return(null);
}
public ResolveVisitor(NRefactoryResolver resolver)
{
this.resolver = resolver;
}
public LambdaResolver(NRefactoryResolver resolver)
{
this.resolver = resolver;
}
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, 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;
((MethodResolveResult)result).StaticUsage = isStatic;
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(NRefactoryResolver.ConvertTypeReference(typeReference)));
}
((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(NRefactoryResolver.ConvertTypeReference(arg))));
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);
}
