Example #1
0
        private static List <ITypeSymbol> GetUsedTypesRecursively(CSharpCompilation compilation, SyntaxTree sourceTree, ref List <ITypeSymbol> currentUsedTypes, ref List <SourceSyntaxTree> sourceSyntaxTrees)
        {
            List <string>      copyCurrentUsedTypes = currentUsedTypes.Select(CT => GetFullyQualifiedTypeName(CT)).ToList();
            List <ITypeSymbol> usedTypes            = GetUsedTypes(compilation, sourceTree)
                                                      .Where(T => !copyCurrentUsedTypes.Contains(GetFullyQualifiedTypeName(T)))
                                                      .ToList();

            currentUsedTypes.AddRange(usedTypes);

            List <SyntaxTree> searchTrees = new List <SyntaxTree>();

            foreach (ITypeSymbol symbol in usedTypes)
            {
                SyntaxReference sr = symbol.DeclaringSyntaxReferences.FirstOrDefault();
                if (sr != null)
                {
                    SourceSyntaxTree sst = sourceSyntaxTrees.FirstOrDefault(SST => SST.SyntaxTree == sr.SyntaxTree);
                    if (sst != null)
                    {
                        sst.UsedTypes.Add(symbol);
                    }
                    string fullyQualifiedTypeName = GetFullyQualifiedTypeName(symbol);
                    searchTrees.Add(sr.SyntaxTree);
                }
            }

            searchTrees = searchTrees.Distinct().ToList();
            foreach (SyntaxTree tree in searchTrees)
            {
                List <ITypeSymbol> newTypes = GetUsedTypesRecursively(compilation, tree, ref currentUsedTypes, ref sourceSyntaxTrees);
                currentUsedTypes.AddRange(newTypes);
            }
            return(currentUsedTypes);
        }
Example #2
0
        private static HashSet <ITypeSymbol> GetUsedTypesRecursively(CSharpCompilation compilation, SyntaxTree sourceTree, ref HashSet <ITypeSymbol> currentUsedTypes, ref List <SourceSyntaxTree> sourceSyntaxTrees)
        {
            HashSet <string> copyCurrentUsedTypes = currentUsedTypes.Select(CT => GetFullyQualifiedTypeName(CT)).ToHashSet();

            HashSet <ITypeSymbol> usedTypes = GetUsedTypes(compilation, sourceTree);

            currentUsedTypes.UnionWith(usedTypes);

            HashSet <SyntaxTree> searchTrees = new HashSet <SyntaxTree>();

            foreach (ITypeSymbol symbol in usedTypes)
            {
                SyntaxReference sr = symbol.DeclaringSyntaxReferences.FirstOrDefault();
                if (sr != null)
                {
                    SourceSyntaxTree sst = sourceSyntaxTrees.FirstOrDefault(SST => SST.SyntaxTree == sr.SyntaxTree);
                    if (sst != null)
                    {
                        sst.UsedTypes.Add(symbol);
                    }
                    string fullyQualifiedTypeName = GetFullyQualifiedTypeName(symbol);
                    searchTrees.Add(sr.SyntaxTree);
                }
            }

            searchTrees.Remove(sourceTree);
            foreach (SyntaxTree tree in searchTrees)
            {
                HashSet <ITypeSymbol> newTypes = GetUsedTypesRecursively(compilation, tree, ref currentUsedTypes, ref sourceSyntaxTrees);
                currentUsedTypes.UnionWith(newTypes);
            }
            return(currentUsedTypes);
        }