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