var codeModule = _vbe.VBProjects.Cast<VBProject>()
                             .First(project => project.Name == selection.ProjectName)
                             .VBComponents.Cast<VBComponent>()
                             .First(component => component.Name == selection.ModuleName)
                             .CodeModule;

        if (codeModule.Find(signature, ref startLine, ref startColumn, ref endLine, ref endColumn))
        {
            codeModule.CodePane.SetSelection(startLine, startColumn, endLine, endColumn);
            codeModule.CodePane.Show();
        }

    private IEnumerable<SyntaxTreeNode> ParseModuleMembers(string publicScope, string localScope, IDictionary<int, string> logicalCodeLines)
    {
        var currentLocalScope = localScope;
        var lines = logicalCodeLines.Values.ToList();
        for (int index = 0; index < lines.Count; index++)
        {
            var line = lines[index];
            var instructions = SplitInstructions(line);
            foreach (var instruction in instructions)
            {
                SyntaxTreeNode node;

        public SyntaxTreeNode(string scope, Match match, string comment, bool hasChildNodes = false)
        {
            _scope = scope;
            _match = match;
            _comment = comment;
            _hasChildNodes = hasChildNodes;
        }

        private readonly string _scope;
        public string Scope { get { return _scope; } }

        private readonly bool _hasChildNodes;
        public bool HasChildNodes { get { return _hasChildNodes; } }

        private readonly Match _match;

        /// <summary>
        /// Gets a value indicating whether syntax is specific to a particular parent node.
        /// </summary>
        /// <remarks>
        /// Implementations with this member set to <c>true</c> will not be considered as part of the general grammar.
        /// </remarks>
        bool IsChildNodeSyntax { get; }

        private IEnumerable<ISyntax> _grammar;

        public Parser()
        {
            var syntaxType = typeof(ISyntax);
            _grammar = Assembly.GetExecutingAssembly()
                               .GetTypes()
                               .Where(type => type.GetInterfaces().Contains(syntaxType))
                               .Select(type => type.GetConstructor(Type.EmptyTypes).Invoke(Type.EmptyTypes))
                               .Cast<ISyntax>()
                               .Where(syntax => !syntax.IsChildNodeSyntax)

    internal class EnumNode : CodeBlockNode
    {
        public EnumNode(string scope, Match match)
            : this(scope, match, string.Empty)
        {

        }

        public EnumNode(string scope, Match match, string comment)
            : base(scope, match, comment, string.Concat(ReservedKeywords.End, " ", ReservedKeywords.Enum), typeof(EnumMemberNode))
        {

        }


    }