public IEnumerable<MemberReference> FindReferences(Solution solution, NamespaceResolveResult resolveResult, IProgressMonitor monitor)
{
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
ProjectDom dom = doc.Dom;
ICompilationUnit unit = doc.CompilationUnit;
string nspace = resolveResult.Namespace;
IEnumerable<INode> searchNodes = (IEnumerable<INode>) new INode[1]{new Namespace(nspace)};
string currentMime = null;
IEnumerable<Tuple<ProjectDom, FilePath>> projFiles = projectFilesExtractor.GetFileNames (solution, dom, unit, monitor);
foreach (Tuple<ProjectDom, FilePath> tuple in projFiles) {
FilePath filePath = tuple.Item2;
if (string.IsNullOrWhiteSpace(filePath.Extension)) continue;
if (monitor != null && monitor.IsCancelRequested) {
break;
}
else {
string mime = DesktopService.GetMimeTypeForUri(filePath);
currentMime = mime;
TextEditorData editor = TextFileProvider.Instance.GetTextEditorData(filePath);
IParser parser = ProjectDomService.GetParser(filePath);
ParsedDocument parsedDoc = parser.Parse(dom, filePath, editor.Text);
int lastFoundIndex = 0;
int column;
int lineOffset;
for (var i = 0; i < editor.Lines.Count(); i++){
var line = editor.GetLineText(i);
if (line != null && line.Contains("using " + nspace + ";")) {
column = line.IndexOf (nspace);
lineOffset = editor.Text.IndexOf(line, lastFoundIndex);
lastFoundIndex = lineOffset + line.Length;
yield return new MemberReference(null, filePath, lineOffset + column, i, column, nspace, nspace);
}
if (line != null &&
(line.Trim().StartsWith("namespace " + nspace + ";") || line.Contains("namespace " + nspace + ";"))) {
column = line.IndexOf (nspace);
lineOffset = editor.Text.IndexOf(line, lastFoundIndex);
lastFoundIndex = lineOffset + line.Length;
yield return new MemberReference(null, filePath, lineOffset + column, i, column, nspace, nspace);
}
}
foreach(var memberRef in FindInnerReferences (monitor, nspace, filePath))
yield return memberRef;
}
}
yield break;
}
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;
}
public ResolveResult Resolve(ExpressionResult expressionResult, DomLocation resolvePosition)
{
this.SetupResolver (resolvePosition);
ResolveVisitor visitor = new ResolveVisitor (this);
ResolveResult result;
// System.Console.WriteLine("expressionResult:" + expressionResult);
if (unit != null && expressionResult.ExpressionContext == ExpressionContext.AttributeArguments) {
string attributeName = NewFSharpExpressionFinder.FindAttributeName (editor, unit, unit.FileName);
if (attributeName != null) {
IType type = dom.SearchType (new SearchTypeRequest (unit, new DomReturnType (attributeName + "Attribute"), CallingType));
if (type == null)
type = dom.SearchType (new SearchTypeRequest (unit, new DomReturnType (attributeName), CallingType));
if (type != null) {
foreach (IProperty property in type.Properties) {
if (property.Name == expressionResult.Expression) {
return new MemberResolveResult (property);
}
}
}
}
}
TypeReference typeRef;
if (expressionResult != null && expressionResult.ExpressionContext != null && expressionResult.ExpressionContext.IsObjectCreation) {
typeRef = ParseTypeReference (expressionResult);
if (typeRef != null) {
if (dom.NamespaceExists (typeRef.Type)) {
// System.Console.WriteLine("namespace resolve result");
result = new NamespaceResolveResult (typeRef.Type);
} else {
result = visitor.CreateResult (ConvertTypeReference (typeRef));
}
// System.Console.WriteLine("type reference resolve result");
result.ResolvedExpression = expressionResult;
if (dom.GetType (result.ResolvedType) != null)
return result;
}
}
expr = ParseExpression (expressionResult);
// System.Console.WriteLine("parsed expression:" + expr);
if (expr == null) {
// System.Console.WriteLine("Can't parse expression");
return null;
}
result = visitor.Resolve (expr);
// if (CallingMember == null && result != null)
// result.StaticResolve = true;
// System.Console.WriteLine("result:" + result + "STATIC" + result.StaticResolve);
result.ResolvedExpression = expressionResult;
return result;
}
public IEnumerable<MemberReference> FindReferences(NamespaceResolveResult resolveResult, IProgressMonitor monitor)
{
return FindReferences(IdeApp.ProjectOperations.CurrentSelectedSolution, resolveResult, monitor);
}
