Merge pull request #2370 from retailcoder/next

retailcoder · web-flow · commit 058ef42d0cc8 · 2016-11-20T15:49:32.000-05:00
some more fixes
diff --git a/RetailCoder.VBE/Root/RubberduckModule.cs b/RetailCoder.VBE/Root/RubberduckModule.cs
@@ -133,6 +133,7 @@ public override void Load()
                 .WhenInjectedInto<ToDoExplorerCommand>()
                 .InSingletonScope();
 
+            BindDockableToolwindows();
             BindCommandsToCodeExplorer();
             ConfigureRubberduckMenu();
             ConfigureCodePaneContextMenu();
@@ -143,6 +144,15 @@ public override void Load()
             BindWindowsHooks();
         }
 
+        private void BindDockableToolwindows()
+        {
+            Kernel.Bind(t => t.FromThisAssembly()
+                .SelectAllClasses()
+                .InheritedFrom<IDockableUserControl>()
+                .BindToSelf()
+                .Configure(binding => binding.InSingletonScope()));
+        }
+
         private void BindWindowsHooks()
         {
             Rebind<IAttachable>().To<TimerHook>()
diff --git a/RetailCoder.VBE/Rubberduck.csproj b/RetailCoder.VBE/Rubberduck.csproj
@@ -896,7 +896,6 @@
     <Compile Include="UI\Splash.Designer.cs">
       <DependentUpon>Splash.cs</DependentUpon>
     </Compile>
-    <Compile Include="UI\ToDoItems\IToDoExplorerWindow.cs" />
     <Compile Include="Settings\IConfigurationService.cs" />
     <Compile Include="Settings\ConfigurationLoader.cs" />
     <Compile Include="Settings\UserSettings.cs" />
diff --git a/RetailCoder.VBE/UI/ToDoItems/IToDoExplorerWindow.cs b/RetailCoder.VBE/UI/ToDoItems/IToDoExplorerWindow.cs
diff --git a/Rubberduck.Parsing/Preprocessing/VBAPrecompilationParser.cs b/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 ExceptionErrorListener()); // notify?
+            VBAConditionalCompilationParser.CompilationUnitContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/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">
diff --git a/Rubberduck.Parsing/Symbols/DeclarationFinder.cs b/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)
diff --git a/Rubberduck.Parsing/Symbols/ExceptionErrorListener.cs b/Rubberduck.Parsing/Symbols/ExceptionErrorListener.cs
@@ -1,4 +1,5 @@
-﻿using Antlr4.Runtime;
+﻿using System;
+using Antlr4.Runtime;
 
 namespace Rubberduck.Parsing.Symbols
 {
diff --git a/Rubberduck.Parsing/Symbols/SyntaxErrorException.cs b/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)
         {
diff --git a/Rubberduck.Parsing/Symbols/SyntaxErrorInfo.cs b/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; } }
+    }
+}
diff --git a/Rubberduck.Parsing/Symbols/SyntaxErrorNotificationListener.cs b/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; } }
+    }
+}
diff --git a/Rubberduck.Parsing/VBA/AttributeParser.cs b/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 ExceptionErrorListener(), out tokenStream);
             return listener.Attributes;
         }
 
diff --git a/Rubberduck.Parsing/VBA/ComponentParseTask.cs b/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, new ExceptionErrorListener(), 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)
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -507,14 +507,16 @@ private Task ParseAsync(IVBComponent component, CancellationTokenSource token, T
             return task;
         }
 
-        private void Cancel()
+        private void Cancel(bool createNewTokenSource = true)
         {
             lock (_cancellationTokens[0])
             {
                 _cancellationTokens[0].Cancel();
-
                 _cancellationTokens[0].Dispose();
-                _cancellationTokens.Add(new CancellationTokenSource());
+                if (createNewTokenSource)
+                {
+                    _cancellationTokens.Add(new CancellationTokenSource());
+                }
                 _cancellationTokens.RemoveAt(0);
             }
         }
@@ -641,16 +643,7 @@ private void ResolveReferences(DeclarationFinder finder, IVBComponent component,
         public void Dispose()
         {
             State.ParseRequest -= ReparseRequested;
-
-            if (_cancellationTokens[0] != null)
-            {
-                try
-                {
-                    _cancellationTokens[0].Cancel();
-                    _cancellationTokens[0].Dispose();
-                }
-                catch (ObjectDisposedException) { /* todo: avoid this being thrown in the first place */ }
-            }
+            Cancel(false);
         }
     }
 }
diff --git a/Rubberduck.Parsing/VBA/VBADateLiteralParser.cs b/Rubberduck.Parsing/VBA/VBADateLiteralParser.cs
@@ -1,9 +1,9 @@
 ﻿using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using NLog;
-using Rubberduck.Parsing.Symbols;
 using System;
 using Rubberduck.Parsing.Preprocessing;
+using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Parsing.VBA
 {
@@ -22,8 +22,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 ExceptionErrorListener()); // notify?
+            VBADateParser.CompilationUnitContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;
diff --git a/Rubberduck.Parsing/VBA/VBAExpressionParser.cs b/Rubberduck.Parsing/VBA/VBAExpressionParser.cs
@@ -2,7 +2,6 @@
 using Antlr4.Runtime.Atn;
 using NLog;
 using Rubberduck.Parsing.Grammar;
-using Rubberduck.Parsing.Symbols;
 using System;
 
 namespace Rubberduck.Parsing.VBA
@@ -22,8 +21,8 @@ public ParserRuleContext Parse(string expression)
             var lexer = new VBALexer(stream);
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBAParser(tokens);
-            parser.AddErrorListener(new ExceptionErrorListener());
-            ParserRuleContext tree = null;
+            //parser.AddErrorListener(new ExceptionErrorListener());
+            ParserRuleContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;
diff --git a/Rubberduck.Parsing/VBA/VBALikePatternParser.cs b/Rubberduck.Parsing/VBA/VBALikePatternParser.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 VBALikeParser.LikePatternStringContext Parse(string likePattern)
             var lexer = new VBALikeLexer(stream);
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBALikeParser(tokens);
-            parser.AddErrorListener(new ExceptionErrorListener());
-            VBALikeParser.CompilationUnitContext tree = null;
+            //parser.AddErrorListener(new ExceptionErrorListener());
+            VBALikeParser.CompilationUnitContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;
diff --git a/Rubberduck.Parsing/VBA/VBAModuleParser.cs b/Rubberduck.Parsing/VBA/VBAModuleParser.cs
@@ -3,7 +3,6 @@
 using Antlr4.Runtime.Tree;
 using NLog;
 using Rubberduck.Parsing.Grammar;
-using Rubberduck.Parsing.Symbols;
 using System;
 
 namespace Rubberduck.Parsing.VBA
@@ -12,14 +11,14 @@ public sealed class VBAModuleParser
     {
         private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
-        public IParseTree Parse(string moduleName, string moduleCode, IParseTreeListener[] listeners, out ITokenStream outStream)
+        public IParseTree Parse(string moduleName, string moduleCode, IParseTreeListener[] listeners, BaseErrorListener errorListener, out ITokenStream outStream)
         {
             var stream = new AntlrInputStream(moduleCode);
             var lexer = new VBALexer(stream);
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBAParser(tokens);
-            parser.AddErrorListener(new ExceptionErrorListener());
-            ParserRuleContext tree = null;
+            parser.AddErrorListener(errorListener);
+            ParserRuleContext tree;
             try
             {
                 parser.Interpreter.PredictionMode = PredictionMode.Sll;
diff --git a/Rubberduck.Parsing/VBA/WalkerCancelledException.cs b/Rubberduck.Parsing/VBA/WalkerCancelledException.cs
diff --git a/Rubberduck.VBEEditor/SafeComWrappers/ComWrapperEnumerator.cs b/Rubberduck.VBEEditor/SafeComWrappers/ComWrapperEnumerator.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Rubberduck.VBEditor.SafeComWrappers
 {
@@ -13,7 +14,9 @@ public class ComWrapperEnumerator<TWrapperItem> : IEnumerator<TWrapperItem>
         public ComWrapperEnumerator(IEnumerable source, Func<object, TWrapperItem> itemWrapper)
         {
             _itemWrapper = itemWrapper;
-            _internal = source.GetEnumerator();
+            _internal = source == null 
+                ? Enumerable.Empty<TWrapperItem>().GetEnumerator() 
+                : source.GetEnumerator();
         }
 
         public void Dispose()
diff --git a/RubberduckTests/Grammar/VBAParserTests.cs b/RubberduckTests/Grammar/VBAParserTests.cs
@@ -1551,7 +1551,8 @@ private Tuple<VBAParser, ParserRuleContext> Parse(string code)
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBAParser(tokens);
             // Don't remove this line otherwise we won't get notified of parser failures.
-            parser.AddErrorListener(new ExceptionErrorListener());
+            parser.ErrorHandler = new BailErrorStrategy();
+            //parser.AddErrorListener(new ExceptionErrorListener());
             // If SLL fails we want to get notified ASAP so we can fix it, that's why we don't retry using LL.
             parser.Interpreter.PredictionMode = PredictionMode.Sll;
             var tree = parser.startRule();
diff --git a/RubberduckTests/Preprocessing/VBAPreprocessorVisitorTests.cs b/RubberduckTests/Preprocessing/VBAPreprocessorVisitorTests.cs
@@ -1268,7 +1268,8 @@ private Tuple<SymbolTable<string, IValue>, IValue> Preprocess(string code)
             var lexer = new VBALexer(stream);
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBAConditionalCompilationParser(tokens);
-            parser.AddErrorListener(new ExceptionErrorListener());
+            parser.ErrorHandler = new BailErrorStrategy();
+            //parser.AddErrorListener(new ExceptionErrorListener());
             var tree = parser.compilationUnit();
             var evaluator = new VBAPreprocessorVisitor(symbolTable, new VBAPredefinedCompilationConstants(7.01), tree.start.InputStream);
             var expr = evaluator.Visit(tree);

Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public IEnumerable<Declaration> MatchName(string name)`
`103`	`103`	`{`
`104`	`104`	`return result;`
`105`	`105`	`}`
`106`		`- return new List<Declaration>();`
	`106`	`+ return Enumerable.Empty<Declaration>();`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`public Declaration FindProject(string name, Declaration currentScope = null)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using Antlr4.Runtime;`
	`1`	`+using System;`
	`2`	`+using Antlr4.Runtime;`
`2`	`3`
`3`	`4`	`namespace Rubberduck.Parsing.Symbols`
`4`	`5`	`{`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,9 @@ public class SyntaxErrorException : Exception`
`13`	`13`	`{`
`14`	`14`	`private static readonly Logger Logger = LogManager.GetCurrentClassLogger();`
`15`	`15`
	`16`	`+ public SyntaxErrorException(SyntaxErrorInfo info)`
	`17`	`+ : this(info.Message, info.Exception, info.OffendingSymbol, info.LineNumber, info.Position) { }`
	`18`	`+`
`16`	`19`	`public SyntaxErrorException(string message, RecognitionException innerException, IToken offendingSymbol, int line, int position)`
`17`	`20`	`: base(message, innerException)`
`18`	`21`	`{`