void TestCollectFiles(Project project, IEnumerable <IEntity> entities, IEnumerable <Tuple <Project, IEnumerable <FilePath> > > expected) { VerifyResult(SearchCollector.CollectFiles(project, entities).ToList(), expected.ToList()); }
static IEnumerable <SearchCollector.FileList> GetFileNames(Solution solution, object node, RefactoryScope scope, IProgressMonitor monitor, IEnumerable <object> searchNodes) { if (!(node is IField) && node is IVariable || scope == RefactoryScope.File) { string fileName; if (node is IEntity) { fileName = ((IEntity)node).Region.FileName; } else if (node is ITypeParameter) { fileName = ((ITypeParameter)node).Region.FileName; } else { fileName = ((IVariable)node).Region.FileName; } var fileList = GetFileList(fileName); if (fileList != null) { yield return(fileList); } yield break; } if (node is ITypeParameter) { var typeParameter = node as ITypeParameter; if (typeParameter.Owner != null) { yield return(SearchCollector.CollectDeclaringFiles(typeParameter.Owner)); yield break; } var fileList = GetFileList(typeParameter.Region.FileName); if (fileList != null) { yield return(fileList); } yield break; } var compilationProvider = (ICompilationProvider)node; switch (scope) { case RefactoryScope.DeclaringType: var entity = (IEntity)compilationProvider; if (entity.DeclaringTypeDefinition != null) { yield return(SearchCollector.CollectDeclaringFiles(entity.DeclaringTypeDefinition)); } else { yield return(SearchCollector.CollectDeclaringFiles(entity)); } break; case RefactoryScope.Project: var sourceProject = TypeSystemService.GetProject(compilationProvider.Compilation.MainAssembly.UnresolvedAssembly.Location); foreach (var file in SearchCollector.CollectFiles(sourceProject, searchNodes)) { yield return(file); } break; default: var files = SearchCollector.CollectFiles(solution, searchNodes).ToList(); if (monitor != null) { monitor.BeginTask(GettextCatalog.GetString("Searching for references in solution..."), files.Count); } foreach (var file in files) { if (monitor != null && monitor.IsCancelRequested) { yield break; } yield return(file); if (monitor != null) { monitor.Step(1); } } if (monitor != null) { monitor.EndTask(); } break; } }
void TestCollectProjects(Solution solution, IEnumerable <IEntity> entities, IEnumerable <Project> expected) { VerifyResult(SearchCollector.CollectProjects(solution, entities).ToList(), expected.ToList()); }
/// <summary> /// collect members with the same signature/name(if overloads are included) as the specified member /// in the inheritance tree /// </summary> public static IEnumerable <IMember> CollectMembers(Solution solution, IMember member, ReferenceFinder.RefactoryScope scope, bool includeOverloads = true, bool matchDeclaringType = false) { if (solution == null || member.SymbolKind == SymbolKind.Destructor || member.SymbolKind == SymbolKind.Operator) { return new [] { member } } ; if (member.SymbolKind == SymbolKind.Constructor) { if (includeOverloads) { return(member.DeclaringType.GetMembers(m => m.SymbolKind == SymbolKind.Constructor, GetMemberOptions.IgnoreInheritedMembers)); } return(new [] { member }); } Func <IMember, bool> memberFilter = null; if (member is IParameterizedMember && !includeOverloads) { memberFilter = m => MatchParameters(m, member); } var declaringType = member.DeclaringTypeDefinition; if (declaringType == null) { return new [] { member } } ; // only collect members in declaringType if (matchDeclaringType) { return(GetMembers(declaringType, member, true, memberFilter)); } if (declaringType.Kind != TypeKind.Class && declaringType.Kind != TypeKind.Interface) { return(GetMembers(declaringType, member, false, memberFilter)); } var searchTypes = new List <ITypeDefinition> (); if (includeOverloads) { var interfaces = from t in declaringType.GetAllBaseTypeDefinitions() where t.Kind == TypeKind.Interface && GetMembers(t, member, true, memberFilter).Any() select t; searchTypes.AddRange(GetBaseTypes(interfaces)); } if (member.DeclaringType.Kind == TypeKind.Class) { var members = GetMembers(declaringType, member, false, memberFilter).ToList(); if (members.Any(m => m.IsOverridable)) { searchTypes.AddRange(GetBaseTypes(members.Select(m => m.DeclaringTypeDefinition))); } else if (searchTypes.Count == 0) { return(members); } } IList <ICompilation> compilations; if (scope == ReferenceFinder.RefactoryScope.Solution || scope == ReferenceFinder.RefactoryScope.Unknown) { var projects = SearchCollector.CollectProjects(solution, searchTypes); compilations = projects.Select(TypeSystemService.GetCompilation).ToList(); } else { compilations = new [] { member.Compilation }; } var result = new List <IMember> (); var mainAssemblies = new HashSet <string> (compilations.Select(c => c.MainAssembly.AssemblyName)); var searchedAssemblies = new HashSet <string> (); var searchedTypes = new HashSet <string> (); foreach (var compilation in compilations) { var baseTypeImports = Import(compilation, searchTypes).Where(t => t != null).ToList(); if (!baseTypeImports.Any()) { continue; } foreach (var assembly in compilation.Assemblies) { // search main assemblies in their projects' own compilation, to avoid possible resolving problems if ((mainAssemblies.Contains(assembly.AssemblyName) && assembly != compilation.MainAssembly) || !searchedAssemblies.Add(assembly.AssemblyName)) { continue; } foreach (var type in assembly.GetAllTypeDefinitions()) { // members in base types will also be added // because IsDerivedFrom return true for a type itself if (!searchedTypes.Add(type.ReflectionName) || !baseTypeImports.Any(type.IsDerivedFrom)) { continue; } result.AddRange(GetMembers(type, member, true, memberFilter)); } } } if (!result.Contains(member)) { result.Add(member); } return(result); } } }