Merge pull request #2797 from rubberduck-vba/next

Release 2.0.12

Author: retailcoder

Installer Build Script.iss

@@ -27,7 +27,6 @@ OutputDir={#OutputDirectory}
 OutputBaseFilename=Rubberduck.Setup.{#AppVersion}
 Compression=lzma
 SolidCompression=yes
-SignTool=RubberduckSignTool /d $qRubberduck Installer$q $f
 
 ArchitecturesAllowed=x86 x64
 ArchitecturesInstallIn64BitMode=x64
@@ -53,6 +52,9 @@ Filename: "{dotnet4064}\RegAsm.exe"; Parameters: "/codebase {#AddinDLL}"; Workin
 Filename: "{dotnet4032}\RegAsm.exe"; Parameters: "/u {#AddinDLL}"; WorkingDir: "{app}"; StatusMsg: "Unregistering Controls..."; Flags: runascurrentuser runminimized; Check: Is32BitOfficeInstalled
 Filename: "{dotnet4064}\RegAsm.exe"; Parameters: "/u {#AddinDLL}"; WorkingDir: "{app}"; StatusMsg: "Unregistering Controls..."; Flags: runascurrentuser runminimized; Check: Is64BitOfficeInstalled
 
+[UninstallDelete]
+Type: filesandordirs; Name: "{localappdata}\{#AppName}"
+
 [CustomMessages]
 ; TODO add additional languages here.
 English.NETFramework40NotInstalled=Microsoft .NET Framework 4.0 installation was not detected.

README.md

@@ -81,17 +81,19 @@ LibGit2Sharp is the library that has allowed us to integrate Git right into the
 
 Which basically means it's a reimplementation of Git in C. It also [happens to be the technology Microsoft uses for their own Git integration with Visual Studio](http://www.hanselman.com/blog/GitSupportForVisualStudioGitTFSAndVSPutIntoContext.aspx).
 
-###[WPF Localization Using RESX Files](http://www.codeproject.com/Articles/35159/WPF-Localization-Using-RESX-Files)
+###[AvalonEdit](http://avalonedit.net)
 
-This library makes localizing WPF applications at runtime using resx files a breeze. Thank you [Grant Frisken](http://www.codeproject.com/script/Membership/View.aspx?mid=1079060)!
+Source code looks a lot better with syntax highlighting, and AvalonEdit excels at it. 
 
-> Licensed under [The Code Project Open License](http://www.codeproject.com/info/cpol10.aspx) with the [author's permission](http://www.codeproject.com/Messages/5272045/Re-License.aspx) to re-release under the GPLv3.
+> AvalonEdit is a WPF-based text editor component. It was written by [Daniel Grunwald](https://github.com/dgrunwald) for the [SharpDevelop](http://www.icsharpcode.net/OpenSource/SD/) IDE. Starting with version 5.0, AvalonEdit is released under the [MIT license](http://opensource.org/licenses/MIT).
 
-###[Using Raw Input from C# to handle multiple keyboards](http://www.codeproject.com/Articles/17123/Using-Raw-Input-from-C-to-handle-multiple-keyboard)
+We're currently only using a tiny bit of this code editor's functionality (more to come!).
+
+###[WPF Localization Using RESX Files](http://www.codeproject.com/Articles/35159/WPF-Localization-Using-RESX-Files)
 
-A library using the Raw Input API for reacting to low level keyboard/mouse events.
+This library makes localizing WPF applications at runtime using resx files a breeze. Thank you [Grant Frisken](http://www.codeproject.com/script/Membership/View.aspx?mid=1079060)!
 
-> Licensed under [The Code Project Open License](http://www.codeproject.com/info/cpol10.aspx).
+> Licensed under [The Code Project Open License](http://www.codeproject.com/info/cpol10.aspx) with the [author's permission](http://www.codeproject.com/Messages/5272045/Re-License.aspx) to re-release under the GPLv3.
 
 ##Icons
 
@@ -107,4 +109,92 @@ If you can't or don't want to provide attribution, please [purchase a royalty-fr
 
 ###[SharpDevelop](https://github.com/icsharpcode/SharpDevelop.git)
 
-Icons in the `./Resources/Custom/` directory were created by (or modified using elements from) the SharpDevelop icon set licensed under the [MIT license](https://opensource.org/licenses/MIT).
+Icons in the `./Resources/Custom/` directory were created by (or modified using elements from) the SharpDevelop icon set licensed under the [MIT license](https://opensource.org/licenses/MIT).
+
+---
+
+##[JetBrains](https://www.jetbrains.com) | [ReSharper](https://www.jetbrains.com/resharper/)
+
+[![JetBrains ReSharper logo](https://cloud.githubusercontent.com/assets/5751684/20271309/616bb740-aa58-11e6-91c9-65287b740985.png)](https://www.jetbrains.com/resharper/)
+
+Since the project's early days, JetBrains' Open-Source team has been supporting Rubberduck - and we deeply thank them for that. ReSharper has been not only a tool we couldn't do without; it's been an inspiration, the ultimate level of polished perfection to strive for in our own IDE add-in project. So just like you're missing out if you write VBA and you're not using Rubberduck, you're missing out if you write C# and aren't using ReSharper.
+
+<sub>Note: Rubberduck is not a JetBrains product. JetBrains does not contribute and is not affiliated to the Rubberduck project in any way.</sub>
+
+---
+
+# Overview
+
+The first thing you will notice of Rubberduck is its commandbar and menus; Rubberduck becomes part of the VBE, but at startup you'll notice almost everything is disabled, and the Rubberduck commandbar says "Pending":
+
+![A 'Refresh' button, and 'Pending' state label in the Rubberduck commandbar](https://cloud.githubusercontent.com/assets/5751684/21707782/2e5a1a42-d3a0-11e6-87a3-c36ff65f9a79.png)
+
+This button is how Rubberduck keeps in sync with what's in the IDE: when it's Rubberduck itself making changes to the code, it will refresh automatically, but if you make changes to the code and then want to use Rubberduck features, you'll need Rubberduck to *parse* the code first.
+
+The status label will display various steps:
+
+ - **Loading declarations**: Rubberduck noticed new project references and is retrieving information from the COM type libraries.
+ - **Parsing**: Rubberduck is creating a parse tree for each new module, and/or updating the parse trees for the modified ones.
+ - **Resolving declarations**: The parse trees are being traversed to identify all declarations (variables, procedures, parameters, locals, ...line labels, *everything*).
+ - **Resolving references**: The parse trees are being traversed again, this time to locate all identifier references and resolve them all to a specific declaration.
+ - **Inspecting**: At this point most features are enabled already; Rubberduck is running its inspections and displaying the results in the *inspection results* toolwindow.
+ 
+That's if everything goes well. Rubberduck assumes the code it's parsing is valid, compilable code that VBA itself can understand.
+
+It's possible you encounter (or write!) code that VBA has no problem with, but that Rubberduck's parser can't handle. When that's the case the Rubberduck commandbar will feature an "error" button:
+ 
+![button tooltip is "1 module(s) failed to parse; click for details."](https://cloud.githubusercontent.com/assets/5751684/21708236/810e9ade-d3a4-11e6-8b4c-c4ec223c066a.png)
+
+Clicking the button brings up a tab in the *Search Results* toolwindow, from which you can double-click to navigate to the exact problematic position in the code:
+
+![Parser errors are all displayed in a "Parser Errors" search results tab](https://cloud.githubusercontent.com/assets/5751684/21708348/86e64b72-d3a5-11e6-9aa8-60cd8d0bec33.png)
+
+The *Code Explorer* will also be displaying the corresponding module node with a red cross icon:
+
+![Module "ThisWorkbook" didn't parse correctly](https://cloud.githubusercontent.com/assets/5751684/21708276/e8f67e50-d3a4-11e6-8c1d-e84d4e9ccce6.png)
+
+You'll find the *Code Explorer* under the *Navigate* menu. By default the Ctrl+R hotkey to display it instead of the VBE's own *Project Explorer*. The treeview lists not only modules, but also every single one of their members, with their signatures if you want. And you can make it arrange your modules into folders, simply by adding a `@Folder("Parent.Child")` annotation/comment to your modules:
+
+![Code Explorer toolwindow](https://cloud.githubusercontent.com/assets/5751684/21708614/90335a46-d3a8-11e6-9e76-61cc3f566c7a.png)
+
+The *inspection results* toolwindow can be displayed by pressing Ctrl+Shift+i (default hotkey), and allows you to double-click to navigate all potential issues that Rubberduck found in your code.
+
+![inspection results](https://cloud.githubusercontent.com/assets/5751684/21708911/d0c47bc4-d3aa-11e6-88f2-b0c9fcfda7ed.png)
+
+Rubberduck also features a port of the popular "Smart Indenter" add-in (now supports 64-bit hosts, and with a few bugfixes on top of that!), so you can turn this:
+
+````vb
+Sub DoSomething()
+With ActiveCell
+With .Offset(1, 2)
+If .value > 100 Then
+MsgBox "something"
+Else
+MsgBox "something else"
+End If
+End With
+End With
+End Sub
+````
+
+Into this:
+
+````vb
+Sub DoSomething()
+    With ActiveCell
+        With .Offset(1, 2)
+            If .value > 100 Then
+                MsgBox "something"
+            Else
+                MsgBox "something else"
+            End If
+        End With
+    End With
+End Sub
+````
+
+...with a single click.
+
+---
+
+There's *quite a lot* to Rubberduck, the above is barely even a "quick tour"; the project's [website](http://www.rubberduckvba.com/) lists all the features, and the [wiki](https://github.com/rubberduck-vba/Rubberduck/wiki) will eventually document everything there is to document. Feel free to poke around and break things and [request features / create new issues](https://github.com/rubberduck-vba/Rubberduck/issues/new) too!

RetailCoder.VBE/API/Declaration.cs

@@ -10,14 +10,18 @@ namespace Rubberduck.API
     [InterfaceType(ComInterfaceType.InterfaceIsDual)]
     public interface IDeclaration
     {
+        [ComVisible(true)]
         string Name { get; }
+        [ComVisible(true)]
         Accessibility Accessibility { get; }
+        [ComVisible(true)]
         DeclarationType DeclarationType { get; }
         string TypeName { get; }
+        [ComVisible(true)]
         bool IsArray { get; }
-
+        [ComVisible(true)]
         Declaration ParentDeclaration { get; }
-
+        [ComVisible(true)]
         IdentifierReference[] References { get; }
     }
 

RetailCoder.VBE/API/ParserState.cs

@@ -3,20 +3,20 @@
 using System.ComponentModel;
 using System.Linq;
 using System.Runtime.InteropServices;
-using Microsoft.Vbe.Interop;
 using Rubberduck.Common;
+using Rubberduck.Parsing.Symbols.DeclarationLoaders;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.UI.Command.MenuItems;
 using Rubberduck.Parsing.Preprocessing;
 using System.Globalization;
-using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor.SafeComWrappers.VBA;
 
 namespace Rubberduck.API
 {
     [ComVisible(true)]
     public interface IParserState
     {
-        void Initialize(VBE vbe);
+        void Initialize(Microsoft.Vbe.Interop.VBE vbe);
 
         void Parse();
         void BeginParse();
@@ -49,27 +49,36 @@ public sealed class ParserState : IParserState, IDisposable
 
         private RubberduckParserState _state;
         private AttributeParser _attributeParser;
-        private RubberduckParser _parser;
+        private ParseCoordinator _parser;
+        private VBE _vbe;
 
         public ParserState()
         {
             UiDispatcher.Initialize();
         }
 
-        public void Initialize(VBE vbe)
+        public void Initialize(Microsoft.Vbe.Interop.VBE vbe)
         {
             if (_parser != null)
             {
                 throw new InvalidOperationException("ParserState is already initialized.");
             }
 
-            _state = new RubberduckParserState(new Sinks(vbe));
+            _vbe = new VBE(vbe);
+            _state = new RubberduckParserState(null);
             _state.StateChanged += _state_StateChanged;
 
-            Func<IVBAPreprocessor> preprocessorFactory = () => new VBAPreprocessor(double.Parse(vbe.Version, CultureInfo.InvariantCulture));
+            Func<IVBAPreprocessor> preprocessorFactory = () => new VBAPreprocessor(double.Parse(_vbe.Version, CultureInfo.InvariantCulture));
             _attributeParser = new AttributeParser(new ModuleExporter(), preprocessorFactory);
-            _parser = new RubberduckParser(vbe, _state, _attributeParser, preprocessorFactory,
-                new List<ICustomDeclarationLoader> { new DebugDeclarations(_state), new FormEventDeclarations(_state), new AliasDeclarations(_state) });
+            _parser = new ParseCoordinator(_vbe, _state, _attributeParser, preprocessorFactory,
+                new List<ICustomDeclarationLoader>
+                {
+                    new DebugDeclarations(_state),
+                    new SpecialFormDeclarations(_state),
+                    new FormEventDeclarations(_state),
+                    new AliasDeclarations(_state),
+                    //new RubberduckApiDeclarations(_state)
+                });
         }
 
         /// <summary>
@@ -94,7 +103,7 @@ public void BeginParse()
         public event Action OnReady;
         public event Action OnError;
 
-        private void _state_StateChanged(object sender, System.EventArgs e)
+        private void _state_StateChanged(object sender, EventArgs e)
         {
             _allDeclarations = _state.AllDeclarations
                                      .Select(item => new Declaration(item))
@@ -151,6 +160,8 @@ public void Dispose()
                 _state.StateChanged -= _state_StateChanged;
             }
 
+
+            _vbe.Release();            
             _disposed = true;
         }
     }