public ProcedureNode(VBAParser.SubStmtContext context, string scope, string localScope)
     : this(context, scope, localScope, VBProcedureKind.Sub, context.visibility(), context.ambiguousIdentifier(), null)
 {
     _argsListContext = context.argList();
     _staticNode = context.STATIC();
     _keyword = context.SUB();
 }

        /// <summary>
        /// Exports the specified component to a temporary file, loads, and then parses the exported file.
        /// </summary>
        /// <param name="component"></param>
        public IDictionary<Tuple<string, DeclarationType>, Attributes> Parse(VBComponent component)
        {
            var path = _exporter.Export(component);
            if (!File.Exists(path))
            {
                // a document component without any code wouldn't be exported (file would be empty anyway).
                return new Dictionary<Tuple<string, DeclarationType>, Attributes>();
            }

            var code = File.ReadAllText(path);
            File.Delete(path);

            var type = component.Type == vbext_ComponentType.vbext_ct_StdModule
                ? DeclarationType.Module
                : DeclarationType.Class;
            var listener = new AttributeListener(Tuple.Create(component.Name, type));

            var stream = new AntlrInputStream(code);
            var lexer = new VBALexer(stream);
            var tokens = new CommonTokenStream(lexer);
            var parser = new VBAParser(tokens);

            // parse tree isn't usable for declarations because
            // line numbers are offset due to module header and attributes
            // (these don't show up in the VBE, that's why we're parsing an exported file)
            var tree = parser.startRule();
            ParseTreeWalker.Default.Walk(listener, tree);

            return listener.Attributes;
        }

        public void ParsesEmptyForm()
        {
            var code = @"
VERSION 5.00
Begin {C62A69F0-16DC-11CE-9E98-00AA00574A4F} Form1 
   Caption         =   ""Form1""
   ClientHeight    =   2640
   ClientLeft      =   45
   ClientTop       =   375
   ClientWidth     =   4710
   OleObjectBlob   =   ""Form1.frx"":0000
   StartUpPosition =   1  'CenterOwner
End
Attribute VB_Name = ""Form1""
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
";
            var stream = new AntlrInputStream(code);
            var lexer = new VBALexer(stream);
            var tokens = new CommonTokenStream(lexer);
            var parser = new VBAParser(tokens);
            parser.ErrorListeners.Clear();
            parser.ErrorListeners.Add(new ExceptionErrorListener());
            var tree = parser.startRule();
            Assert.IsNotNull(tree);
        }

 public override void EnterICS_S_VariableOrProcedureCall(VBAParser.ICS_S_VariableOrProcedureCallContext context)
 {
     if (context.Parent.GetType() != typeof (VBAParser.ICS_S_MemberCallContext))
     {
         _resolver.Resolve(context);
     }
 }

        /// <summary>
        /// Gets the <c>Accessibility</c> for a procedure member.
        /// </summary>
        private Accessibility GetProcedureAccessibility(VBAParser.VisibilityContext visibilityContext)
        {
            var visibility = visibilityContext == null
                ? "Implicit" // "Public"
                : visibilityContext.GetText();

            return (Accessibility)Enum.Parse(typeof(Accessibility), visibility);
        }

 private bool HasExplicitCallStatement(VBAParser.ECS_ProcedureCallContext call)
 {
     if (call == null)
     {
         return false;
     }
     var statement = call.CALL();
     return statement != null && statement.Symbol.Text == Tokens.Call;
 }

        private ProcedureNode GetNode(VBAParser.PropertyGetStmtContext context)
        {
            if (context == null)
            {
                return null;
            }

            var scope = Selection.QualifiedName.ToString();
            var localScope = scope + "." + context.ambiguousIdentifier().GetText();
            return new ProcedureNode(context, scope, localScope);
        }

        private string DeclareExplicitVariant(VBAParser.ArgContext context, out string instruction)
        {
            if (context == null)
            {
                instruction = null;
                return null;
            }

            instruction = context.GetText();
            return instruction + ' ' + Tokens.As + ' ' + Tokens.Variant;
        }

 public IAnnotation Create(VBAParser.AnnotationContext context, QualifiedSelection qualifiedSelection)
 {
     string annotationName = context.annotationName().GetText();
     List<string> parameters = new List<string>();
     var argList = context.annotationArgList();
     if (argList != null)
     {
         parameters.AddRange(argList.annotationArg().Select(arg => arg.GetText()));
     }
     Type annotationCLRType = null;
     if (_creators.TryGetValue(annotationName.ToUpperInvariant(), out annotationCLRType))
     {
         return (IAnnotation)Activator.CreateInstance(annotationCLRType, qualifiedSelection, parameters);
     }
     return null;
 }

        public IParseTree Parse(string code, out ITokenStream outStream)
        {
            var input = new AntlrInputStream(code);
            var lexer = new VBALexer(input);
            var tokens = new CommonTokenStream(lexer);
            var parser = new VBAParser(tokens);
            parser.AddErrorListener(new ExceptionErrorListener());
            outStream = tokens;

            var result = parser.startRule();
            return result;
        }

            public override void EnterAmbiguousIdentifier(VBAParser.AmbiguousIdentifierContext context)
            {
                DeclarationType type;
                if (!ScopingContextTypes.TryGetValue(context.Parent.GetType(), out type))
                {
                    return;
                }

                _currentScope = Tuple.Create(context.GetText(), type);
            }

 public override void ExitModuleAttributes(VBAParser.ModuleAttributesContext context)
 {
     _attributes.Add(_currentScope, _currentScopeAttributes);
 }

 public override void ExitModuleConfigElement(VBAParser.ModuleConfigElementContext context)
 {
     var name = context.ambiguousIdentifier().GetText();
     var literal = context.literal();
     var values = new[] { literal == null ? string.Empty : literal.GetText()};
     _currentScopeAttributes.Add(name, values);
 }

 public override void ExitAttributeStmt(VBAParser.AttributeStmtContext context)
 {
     var name = context.implicitCallStmt_InStmt().GetText().Trim();
     var values = context.literal().Select(e => e.GetText().Replace("\"", string.Empty)).ToList();
     _currentScopeAttributes.Add(name, values);
 }

 public override void ExitPropertySetStmt(VBAParser.PropertySetStmtContext context)
 {
     if (!string.IsNullOrEmpty(_currentScope.Item1) && _currentScopeAttributes.Any())
     {
         _attributes.Add(_currentScope, _currentScopeAttributes);
     }
 }

 public override void EnterPropertySetStmt(VBAParser.PropertySetStmtContext context)
 {
     _currentScopeAttributes = new Attributes();
     _currentScope = Tuple.Create(context.ambiguousIdentifier().GetText(), DeclarationType.PropertySet);
 }

 public override void ExitArgList(VBAParser.ArgListContext context)
 {
     if (context.arg() != null && context.arg().Count(a => a.BYREF() != null || (a.BYREF() == null && a.BYVAL() == null)) == 1)
     {
         _contexts.Add(context);
     }
 }

 public override void ExitLiteral(VBAParser.LiteralContext context)
 {
     var literal = context.STRINGLITERAL();
     if (literal != null && literal.GetText() == "\"\"")
     {
         _contexts.Add(context);
     }
 }

 private void AssertTree(VBAParser parser, ParserRuleContext root, string xpath)
 {
     AssertTree(parser, root, xpath, matches => matches.Count >= 1);
 }

 public override void EnterWithStmt(VBAParser.WithStmtContext context)
 {
     _resolver.EnterWithBlock(context);
 }