removed bail-out error strategy to let ANTLR recover parse errors. tests still pass, but need to tweak parser/resolver to handle parse tree nodes with a recognitionexception now.

Author: retailcoder

Rubberduck.Parsing/Preprocessing/VBAPrecompilationParser.cs

@@ -17,8 +17,8 @@ public VBAConditionalCompilationParser.CompilationUnitContext Parse(string modul
             var lexer = new VBALexer(stream);
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBAConditionalCompilationParser(tokens);
-            parser.AddErrorListener(new ExceptionErrorListener());
-            VBAConditionalCompilationParser.CompilationUnitContext tree = null;
+            //parser.AddErrorListener(new SyntaxErrorNotificationListener()); // notify?
+            VBAConditionalCompilationParser.CompilationUnitContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;

Rubberduck.Parsing/Rubberduck.Parsing.csproj

@@ -244,6 +244,8 @@
     <Compile Include="Symbols\FunctionDeclaration.cs" />
     <Compile Include="Symbols\SubroutineDeclaration.cs" />
     <Compile Include="Symbols\ProjectReferencePass.cs" />
+    <Compile Include="Symbols\SyntaxErrorInfo.cs" />
+    <Compile Include="Symbols\SyntaxErrorNotificationListener.cs" />
     <Compile Include="Symbols\TypeHierarchyPass.cs" />
     <Compile Include="Symbols\TypeAnnotationPass.cs" />
     <Compile Include="Symbols\IdentifierReferenceResolver.cs" />
@@ -284,7 +286,6 @@
     <Compile Include="VBA\VBADateLiteralParser.cs" />
     <Compile Include="VBA\VBAExpressionParser.cs" />
     <Compile Include="VBA\VBAModuleParser.cs" />
-    <Compile Include="VBA\WalkerCancelledException.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Grammar\VBAParser.g4">

Rubberduck.Parsing/Symbols/DeclarationFinder.cs

@@ -103,7 +103,7 @@ public IEnumerable<Declaration> MatchName(string name)
             {
                 return result;
             }
-            return new List<Declaration>();
+            return Enumerable.Empty<Declaration>();
         }
 
         public Declaration FindProject(string name, Declaration currentScope = null)

Rubberduck.Parsing/Symbols/ExceptionErrorListener.cs

@@ -1,4 +1,5 @@
-using Antlr4.Runtime;
+using System;
+using Antlr4.Runtime;
 
 namespace Rubberduck.Parsing.Symbols
 {

Rubberduck.Parsing/Symbols/SyntaxErrorException.cs

@@ -13,6 +13,9 @@ public class SyntaxErrorException : Exception
     {
         private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
+        public SyntaxErrorException(SyntaxErrorInfo info)
+            : this(info.Message, info.Exception, info.OffendingSymbol, info.LineNumber, info.Position) { }
+
         public SyntaxErrorException(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position)
             : base(message, innerException)
         {

Rubberduck.Parsing/Symbols/SyntaxErrorInfo.cs

@@ -0,0 +1,31 @@
+using Antlr4.Runtime;
+
+namespace Rubberduck.Parsing.Symbols
+{
+    public class SyntaxErrorInfo
+    {
+        public SyntaxErrorInfo(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position)
+        {
+            _message = message;
+            _innerException = innerException;
+            _token = offendingSymbol;
+            _line = line;
+            _position = position;
+        }
+
+        private readonly string _message;
+        public string Message { get { return _message; } }
+
+        private readonly RecognitionException _innerException;
+        public RecognitionException Exception { get { return _innerException; } }
+
+        private readonly IToken _token;
+        public IToken OffendingSymbol { get { return _token; } }
+
+        private readonly int _line;
+        public int LineNumber { get { return _line; } }
+
+        private readonly int _position;
+        public int Position { get { return _position; } }
+    }
+}

Rubberduck.Parsing/Symbols/SyntaxErrorNotificationListener.cs

@@ -0,0 +1,36 @@
+using System;
+using Antlr4.Runtime;
+
+namespace Rubberduck.Parsing.Symbols
+{
+    public class SyntaxErrorNotificationListener : BaseErrorListener
+    {
+        public event EventHandler<SyntaxErrorEventArgs> OnSyntaxError;
+        public override void SyntaxError(IRecognizer recognizer, IToken offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e)
+        {
+            var info = new SyntaxErrorInfo(msg, e, offendingSymbol, line, charPositionInLine);
+            NotifySyntaxError(info);
+        }
+
+        private void NotifySyntaxError(SyntaxErrorInfo info)
+        {
+            var handler = OnSyntaxError;
+            if (handler != null)
+            {
+                handler.Invoke(this, new SyntaxErrorEventArgs(info));
+            }
+        }
+    }
+
+    public class SyntaxErrorEventArgs : EventArgs
+    {
+        private readonly SyntaxErrorInfo _info;
+
+        public SyntaxErrorEventArgs(SyntaxErrorInfo info)
+        {
+            _info = info;
+        }
+
+        public SyntaxErrorInfo Info { get { return _info; } }
+    }
+}

Rubberduck.Parsing/VBA/AttributeParser.cs

@@ -47,7 +47,7 @@ public IDictionary<Tuple<string, DeclarationType>, Attributes> Parse(IVBComponen
             // 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)
             ITokenStream tokenStream;
-            new VBAModuleParser().Parse(component.Name, preprocessed, new IParseTreeListener[] { listener }, out tokenStream);
+            new VBAModuleParser().Parse(component.Name, preprocessed, new IParseTreeListener[] { listener }, new SyntaxErrorNotificationListener(), out tokenStream);
             return listener.Attributes;
         }
 

Rubberduck.Parsing/VBA/ComponentParseTask.cs

@@ -87,6 +87,7 @@ public void Start(CancellationToken token)
             }
             catch (SyntaxErrorException exception)
             {
+                System.Diagnostics.Debug.Assert(false, "A RecognitionException should be notified of, not thrown as a SyntaxErrorException. This lets the parser recover from parse errors.");
                 Logger.Error(exception, "Exception thrown in thread {0}.", Thread.CurrentThread.ManagedThreadId);
                 var failedHandler = ParseFailure;
                 if (failedHandler != null)
@@ -165,7 +166,19 @@ private string RewriteAndPreprocess()
 
         private IParseTree ParseInternal(string moduleName, string code, IParseTreeListener[] listeners, out ITokenStream outStream)
         {
-            return _parser.Parse(moduleName, code, listeners, out outStream);
+            var errorNotifier = new SyntaxErrorNotificationListener();
+            errorNotifier.OnSyntaxError += ParserSyntaxError;
+            return _parser.Parse(moduleName, code, listeners, errorNotifier, out outStream);
+        }
+
+        private void ParserSyntaxError(object sender, SyntaxErrorEventArgs e)
+        {
+            var handler = ParseFailure;
+            if (handler != null)
+            {
+                var args = new ParseFailureArgs {Cause = new SyntaxErrorException(e.Info)}; // todo: refactor. exceptions should be thrown, not passed around as data
+                handler.Invoke(this, args);
+            }
         }
 
         private IEnumerable<CommentNode> QualifyAndUnionComments(QualifiedModuleName qualifiedName, IEnumerable<VBAParser.CommentContext> comments, IEnumerable<VBAParser.RemCommentContext> remComments)

Rubberduck.Parsing/VBA/VBADateLiteralParser.cs

@@ -1,7 +1,6 @@
 using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using NLog;
-using Rubberduck.Parsing.Symbols;
 using System;
 using Rubberduck.Parsing.Preprocessing;
 
@@ -22,8 +21,8 @@ public VBADateParser.DateLiteralContext Parse(string date)
             var lexer = new VBADateLexer(stream);
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBADateParser(tokens);
-            parser.AddErrorListener(new ExceptionErrorListener());
-            VBADateParser.CompilationUnitContext tree = null;
+            //parser.AddErrorListener(new SyntaxErrorNotificationListener()); // notify?
+            VBADateParser.CompilationUnitContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;