using System;

using System.Collections.Generic;

using System.Linq;

using Microsoft.CodeAnalysis;

using Microsoft.CodeAnalysis.CSharp;

using Microsoft.CodeAnalysis.CSharp.Syntax;

    public class Program

    {

        public static void Main()

        {

            var tree = CSharpSyntaxTree.ParseText(@" 

                namespace MyNamespace

                {               

                    #region Class1

                    public class MyClass1  

                    { 

                        int MyMethod1() { return 0; } 

                        #region Test

                        int MyMethod2() { return 0; } 

                        #endregion

                    }

                    #endregion

​

                    public class MyClass2  

                    { 

                        int MyMethod1() { return 0; } 

                        #region Test

                        int MyMethod2() { return 0; } 

                        #endregion

                    }

                }");

​

            var syntaxRoot = tree.GetRoot();

​

            var Mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);

            var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { Mscorlib });

            var model = compilation.GetSemanticModel(tree);

​

            var MyNamespace = syntaxRoot.DescendantNodes().OfType<NamespaceDeclarationSyntax>().First();

            var MyClass1 = MyNamespace.DescendantNodes().OfType<ClassDeclarationSyntax>().First(x => x.Identifier.Text == "MyClass1");

            var MyClass2 = MyNamespace.DescendantNodes().OfType<ClassDeclarationSyntax>().First(x => x.Identifier.Text == "MyClass2");

            var MyClass1Method1 = MyClass1.DescendantNodes().OfType<MethodDeclarationSyntax>().First(x => x.Identifier.Text == "MyMethod1");

            var MyClass1Method2 = MyClass1.DescendantNodes().OfType<MethodDeclarationSyntax>().First(x => x.Identifier.Text == "MyMethod2");

            var MyClass2Method1 = MyClass2.DescendantNodes().OfType<MethodDeclarationSyntax>().First(x => x.Identifier.Text == "MyMethod1");

            var MyClass2Method2 = MyClass2.DescendantNodes().OfType<MethodDeclarationSyntax>().First(x => x.Identifier.Text == "MyMethod2");

​

            HashSet<ISymbol> symbolsToKeep = new HashSet<ISymbol>();

            symbolsToKeep.Add(model.GetDeclaredSymbol(MyNamespace));

            symbolsToKeep.Add(model.GetDeclaredSymbol(MyClass1));

            symbolsToKeep.Add(model.GetDeclaredSymbol(MyClass1Method2));

​

            var rewriter = new SyntaxNodeFilterRewriter(model, symbolsToKeep);

            var result = rewriter.Visit(syntaxRoot);

​

            Console.WriteLine(result.ToFullString());

        }

    }

​

    class SyntaxNodeFilterRewriter : CSharpSyntaxRewriter

    {

        public SemanticModel Model { get; private set; }

        public HashSet<ISymbol> SymbolsToKeep { get; private set; }

​

        public SyntaxNodeFilterRewriter(SemanticModel model, HashSet<ISymbol> symbolsToKeep)

        {

            Model = model;

            SymbolsToKeep = symbolsToKeep;

​

            model.SyntaxTree.GetRoot().TrackNodes();

        }

​

        public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)

        {

            var filteredMembers = FilterMembers(node.Members).ToList();

            var newMembers = SyntaxFactory.List(filteredMembers.Select(m => Visit(m)));

​

            node = node.RemoveNodes(node.Members.Except(FilterMembers(node.Members)), SyntaxRemoveOptions.KeepDirectives);

            node = node.ReplaceNodes(node.Members, (n1, n2) => Visit(n1));

​

            return node;

        }

​

        public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)

        {

            var filteredMembers = FilterMembers(node.Members).ToList();

            var newMembers = SyntaxFactory.List(filteredMembers.Select(m => Visit(m)));

            node = node.RemoveNodes(node.Members.Except(FilterMembers(node.Members)), SyntaxRemoveOptions.KeepDirectives);

            node = node.ReplaceNodes(node.Members, (n1, n2) => Visit(n1));

​

            return node;

        }

​

​

        public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)

        {

            var filteredMembers = FilterMembers(node.Members).ToList();

            var newMembers = SyntaxFactory.List(filteredMembers.Select(m => Visit(m)));

​

            node = node.RemoveNodes(node.Members.Except(FilterMembers(node.Members)), SyntaxRemoveOptions.KeepDirectives);

            node = node.ReplaceNodes(node.Members, (n1, n2) => Visit(n1));

​

            return node;

        }

​

        public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)

        {

            var filteredMembers = FilterMembers(node.Members).ToList();

            var newMembers = SyntaxFactory.List(filteredMembers.Select(m => Visit(m)));

​

            node = node.RemoveNodes(node.Members.Except(FilterMembers(node.Members)), SyntaxRemoveOptions.KeepDirectives);

            node = node.ReplaceNodes(node.Members, (n1, n2) => Visit(n1));

​

            return node;

        }

​

        public override SyntaxNode VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)

        {

            var filteredMembers = FilterMembers(node.Members).ToList();

            var newMembers = SyntaxFactory.List(filteredMembers.Select(m => Visit(m)));

​

            node = node.RemoveNodes(node.Members.Except(FilterMembers(node.Members)), SyntaxRemoveOptions.KeepDirectives);

            node = node.ReplaceNodes(node.Members, (n1, n2) => Visit(n1));

​

            return node;

        }

​

        private bool Filter(SyntaxNode node)

        {

            var symbol = Model.GetDeclaredSymbol(node);

​

            if (symbol == null)

                return true; // better safe than sorry

​

            return SymbolsToKeep.Contains(symbol);

        }

​

        private IEnumerable<MemberDeclarationSyntax> FilterMembers(IEnumerable<MemberDeclarationSyntax> members)

        {

            foreach (var member in members)

            {

                bool keep = false;

​

                if (member is FieldDeclarationSyntax)

                {

                    var fieldDecl = member as FieldDeclarationSyntax;

​

                    if (fieldDecl.Declaration.Variables.Any(v => Filter(v)))

                        keep = true;

                }

                else

                {

                    if (Filter(member))

                        keep = true;

                }

​

                if (keep)

                    yield return member;

            }

        }

    }