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