Merge pull request #2078 from rubberduck-vba/next

Release 2.0.6

Author: Hosch250

README.md

@@ -85,7 +85,7 @@ Which basically means it's a reimplementation of Git in C. It also [happens to b
 
 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.
 
 ###[Using Raw Input from C# to handle multiple keyboards](http://www.codeproject.com/Articles/17123/Using-Raw-Input-from-C-to-handle-multiple-keyboard)
 

RetailCoder.VBE/Common/DeclarationExtensions.cs

@@ -262,6 +262,22 @@ public static IEnumerable<Declaration> FindEventHandlers(this IEnumerable<Declar
                 && declaration.IdentifierName.StartsWith(control.IdentifierName + "_"));
         }
 
+        public static IEnumerable<Declaration> FindUserEventHandlers(this IEnumerable<Declaration> declarations)
+        {
+            var declarationList = declarations.ToList();
+
+            var userEvents =
+                declarationList.Where(item => !item.IsBuiltIn && item.DeclarationType == DeclarationType.Event).ToList();
+
+            var handlers = new List<Declaration>();
+            foreach (var @event in userEvents)
+            {
+                handlers.AddRange(declarations.FindHandlersForEvent(@event).Select(s => s.Item2));
+            }
+            
+            return handlers;
+        }
+
         public static IEnumerable<Declaration> FindBuiltInEventHandlers(this IEnumerable<Declaration> declarations)
         {
             var declarationList = declarations.ToList();
@@ -451,6 +467,12 @@ public static IEnumerable<Declaration> FindInterfaceImplementationMembers(this I
                 .Where(m => m.IdentifierName.EndsWith(interfaceMember));
         }
 
+        public static IEnumerable<Declaration> FindInterfaceImplementationMembers(this IEnumerable<Declaration> declarations, Declaration interfaceDeclaration)
+        {
+            return FindInterfaceImplementationMembers(declarations)
+                .Where(m => m.IdentifierName == interfaceDeclaration.ComponentName + "_" + interfaceDeclaration.IdentifierName);
+        }
+
         public static Declaration FindInterfaceMember(this IEnumerable<Declaration> declarations, Declaration implementation)
         {
             var members = FindInterfaceMembers(declarations);

RetailCoder.VBE/Common/Hotkeys/HotkeyInfo.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Text;
 using System.Windows.Forms;
+using Rubberduck.UI;
 
 namespace Rubberduck.Common.Hotkeys
 {
@@ -25,20 +26,21 @@ public override string ToString()
             var builder = new StringBuilder();
             if (_keys.HasFlag(Keys.Alt))
             {
-                builder.Append(Rubberduck.UI.RubberduckUI.GeneralSettings_HotkeyAlt);
+                builder.Append(RubberduckUI.GeneralSettings_HotkeyAlt);
                 builder.Append('+');
             }
             if (_keys.HasFlag(Keys.Control))
             {
-                builder.Append(Rubberduck.UI.RubberduckUI.GeneralSettings_HotkeyCtrl);
+                builder.Append(RubberduckUI.GeneralSettings_HotkeyCtrl);
                 builder.Append('+');
             }
             if (_keys.HasFlag(Keys.Shift))
             {
-                builder.Append(Rubberduck.UI.RubberduckUI.GeneralSettings_HotkeyShift);
+                builder.Append(RubberduckUI.GeneralSettings_HotkeyShift);
                 builder.Append('+');
             }
-            builder.Append(_keys & ~Modifiers);
+            
+            builder.Append(HotkeyDisplayConverter.Convert(_keys & ~Modifiers));
             return builder.ToString();
         }
     }

RetailCoder.VBE/Common/RubberduckHooks.cs

@@ -5,20 +5,17 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Windows.Forms;
-using System.Windows.Input;
 using Microsoft.Vbe.Interop;
 using Rubberduck.Common.Hotkeys;
 using Rubberduck.Common.WinAPI;
 using Rubberduck.Settings;
 using Rubberduck.UI.Command;
-using Rubberduck.UI.Command.Refactorings;
 using NLog;
 
 namespace Rubberduck.Common
 {
     public class RubberduckHooks : IRubberduckHooks
     {
-        private readonly VBE _vbe;
         private readonly IntPtr _mainWindowHandle;
         private readonly IntPtr _oldWndPointer;
         private readonly User32.WndProc _oldWndProc;
@@ -33,7 +30,6 @@ public class RubberduckHooks : IRubberduckHooks
 
         public RubberduckHooks(VBE vbe, IGeneralConfigService config, IEnumerable<CommandBase> commands)
         {
-            _vbe = vbe;
             _mainWindowHandle = (IntPtr)vbe.MainWindow.HWnd;
             _oldWndProc = WindowProc;
             _newWndProc = WindowProc;
@@ -174,7 +170,7 @@ public void Detach()
         private void hook_MessageReceived(object sender, HookEventArgs e)
         {
             var hotkey = sender as IHotkey;
-            if (hotkey != null)
+            if (hotkey != null && hotkey.Command.CanExecute(null))
             {
                 hotkey.Command.Execute(null);
                 return;

RetailCoder.VBE/Common/WinAPI/RawInput.cs

@@ -39,23 +39,41 @@ protected override void WndProc(ref Message message)
             switch ((WM)message.Msg)
             {
                 case WM.INPUT:
+                {
+                    if (message.LParam == IntPtr.Zero)
+                    {
+                        break;
+                    }
+                    InputData rawBuffer;
+                    var dwSize = 0;
+                    var res = User32.GetRawInputData(message.LParam, DataCommand.RID_INPUT, IntPtr.Zero, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader)));
+                    if (res != 0)
+                    {
+                        var ex = new Win32Exception(Marshal.GetLastWin32Error());
+                        Logger.Error(ex, "Error sizing the rawinput buffer: {0}", ex.Message);
+                        break;                           
+                    }
+
+                    res = User32.GetRawInputData(message.LParam, DataCommand.RID_INPUT, out rawBuffer, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader)));
+                    if (res == -1)
+                    {
+                        var ex = new Win32Exception(Marshal.GetLastWin32Error());
+                        Logger.Error(ex, "Error getting the rawinput buffer: {0}", ex.Message);
+                        break;
+                    }
+                    if (res == dwSize)
                     {
-                        InputData _rawBuffer;
-                        var dwSize = 0;
-                        User32.GetRawInputData(message.LParam, DataCommand.RID_INPUT, IntPtr.Zero, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader)));
-                        int res = User32.GetRawInputData(message.LParam, DataCommand.RID_INPUT, out _rawBuffer, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader)));
-                        if (dwSize != res)
-                        {
-                            var ex = new Win32Exception(Marshal.GetLastWin32Error());
-                            Logger.Error(ex, "Error getting the rawinput buffer: {0}", ex.Message);
-                            return;
-                        }
                         foreach (var device in _devices)
                         {
-                            device.ProcessRawInput(_rawBuffer);
+                            device.ProcessRawInput(rawBuffer);
                         }
                     }
-                    break;
+                    else
+                    {
+                        //Something is seriously f'd up with Windows - the number of bytes copied does not match the reported buffer size.
+                    }
+                }
+                break;
             }
             base.WndProc(ref message);
         }

RetailCoder.VBE/Inspections/AssignedByValParameterInspectionResult.cs

@@ -13,9 +13,10 @@ public class AssignedByValParameterInspectionResult : InspectionResultBase
         public AssignedByValParameterInspectionResult(IInspection inspection, Declaration target)
             : base(inspection, target)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
                 new PassParameterByReferenceQuickFix(target.Context, QualifiedSelection),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/CodeInspectionQuickFix.cs

@@ -1,4 +1,5 @@
-using Antlr4.Runtime;
+using System.Windows.Threading;
+using Antlr4.Runtime;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections
@@ -11,6 +12,9 @@ public abstract class CodeInspectionQuickFix
 
         public CodeInspectionQuickFix(ParserRuleContext context, QualifiedSelection selection, string description)
         {
+            Dispatcher.CurrentDispatcher.Thread.CurrentCulture = UI.Settings.Settings.Culture;
+            Dispatcher.CurrentDispatcher.Thread.CurrentUICulture = UI.Settings.Settings.Culture;
+
             _context = context;
             _selection = selection;
             _description = description;

RetailCoder.VBE/Inspections/EmptyStringLiteralInspection.cs

@@ -26,8 +26,9 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
             {
                 return new InspectionResultBase[] { };
             }
-            return ParseTreeResults.EmptyStringLiterals.Select(
-                    context => new EmptyStringLiteralInspectionResult(this,
+            return ParseTreeResults.EmptyStringLiterals
+                .Where(s => !IsInspectionDisabled(s.ModuleName.Component, s.Context.Start.Line))
+                .Select(context => new EmptyStringLiteralInspectionResult(this,
                             new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
         }
 

RetailCoder.VBE/Inspections/EmptyStringLiteralInspectionResult.cs

@@ -13,9 +13,10 @@ public class EmptyStringLiteralInspectionResult : InspectionResultBase
         public EmptyStringLiteralInspectionResult(IInspection inspection, QualifiedContext<ParserRuleContext> qualifiedContext)
             : base(inspection, qualifiedContext.ModuleName, qualifiedContext.Context)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
-                new RepaceEmptyStringLiteralStatementQuickFix(Context, QualifiedSelection), 
+                new RepaceEmptyStringLiteralStatementQuickFix(Context, QualifiedSelection),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/EncapsulatePublicFieldInspectionResult.cs

@@ -16,9 +16,10 @@ public class EncapsulatePublicFieldInspectionResult : InspectionResultBase
         public EncapsulatePublicFieldInspectionResult(IInspection inspection, Declaration target, RubberduckParserState state)
             : base(inspection, target)
         {
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
                 new EncapsulateFieldQuickFix(target.Context, target.QualifiedSelection, target, state),
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/FunctionReturnValueNotUsedInspectionResult.cs

@@ -34,9 +34,10 @@ public FunctionReturnValueNotUsedInspectionResult(
             var root = new ConvertToProcedureQuickFix(context, QualifiedSelection, returnStatements);
             var compositeFix = new CompositeCodeInspectionFix(root);
             children.ToList().ForEach(child => compositeFix.AddChild(new ConvertToProcedureQuickFix(child.Item1, child.Item2, child.Item3)));
-            _quickFixes = new[]
+            _quickFixes = new CodeInspectionQuickFix[]
             {
-                compositeFix
+                compositeFix,
+                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName)
             };
         }
 

RetailCoder.VBE/Inspections/IParseTreeInspection.cs

@@ -1,6 +1,7 @@
 using Rubberduck.Parsing;
 using System.Collections.Generic;
 using System.Linq;
+using Rubberduck.Parsing.Grammar;
 
 namespace Rubberduck.Inspections
 {
@@ -17,11 +18,13 @@ public ParseTreeResults()
             ObsoleteLetContexts = Enumerable.Empty<QualifiedContext>();
             ArgListsWithOneByRefParam = Enumerable.Empty<QualifiedContext>();
             EmptyStringLiterals = Enumerable.Empty<QualifiedContext>();
+            MalformedAnnotations = Enumerable.Empty<QualifiedContext<VBAParser.AnnotationContext>>();
         }
 
         public IEnumerable<QualifiedContext> ObsoleteCallContexts;
         public IEnumerable<QualifiedContext> ObsoleteLetContexts;
         public IEnumerable<QualifiedContext> ArgListsWithOneByRefParam;
         public IEnumerable<QualifiedContext> EmptyStringLiterals;
+        public IEnumerable<QualifiedContext<VBAParser.AnnotationContext>> MalformedAnnotations;
     }
 }

RetailCoder.VBE/Inspections/ImplicitByRefParameterInspection.cs

@@ -26,7 +26,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             var issues = (from item in UserDeclarations
                 where
-                    !item.IsInspectionDisabled(AnnotationName)
+                    !IsInspectionDisabled(item, AnnotationName)
                     && item.DeclarationType == DeclarationType.Parameter
                     // ParamArray parameters do not allow an explicit "ByRef" parameter mechanism.               
                     && !((ParameterDeclaration)item).IsParamArray

RetailCoder.VBE/Inspections/ImplicitPublicMemberInspection.cs

@@ -30,7 +30,7 @@ public ImplicitPublicMemberInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                         where !item.IsInspectionDisabled(AnnotationName) 
+                         where !IsInspectionDisabled(item, AnnotationName) 
                                && ProcedureTypes.Contains(item.DeclarationType)
                                && item.Accessibility == Accessibility.Implicit
                          let context = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)

RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs

@@ -28,7 +28,7 @@ public ImplicitVariantReturnTypeInspection(RubberduckParserState state)
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var issues = from item in UserDeclarations
-                               where !item.IsInspectionDisabled(AnnotationName)
+                               where !IsInspectionDisabled(item, AnnotationName)
                                 && ProcedureTypes.Contains(item.DeclarationType)
                                 && !item.IsTypeSpecified
                                let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}

RetailCoder.VBE/Inspections/InspectionBase.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 
@@ -73,20 +75,56 @@ protected InspectionBase(RubberduckParserState state, CodeInspectionSeverity def
         /// </summary>
         protected virtual IEnumerable<Declaration> Declarations
         {
-            get { return State.AllDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }
+            get { return State.AllDeclarations.Where(declaration => !IsInspectionDisabled(declaration, AnnotationName)); }
+        }
+
+        /// <summary>
+        /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.
+        /// </summary>
+        protected virtual IEnumerable<Declaration> UserDeclarations
+        {
+            get { return State.AllUserDeclarations.Where(declaration => !IsInspectionDisabled(declaration, AnnotationName)); }
         }
 
         protected virtual IEnumerable<Declaration> BuiltInDeclarations
         {
             get { return State.AllDeclarations.Where(declaration => declaration.IsBuiltIn); }
         }
 
-        /// <summary>
-        /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.
-        /// </summary>
-        protected virtual IEnumerable<Declaration> UserDeclarations
+        protected bool IsInspectionDisabled(VBComponent component, int line)
         {
-            get { return State.AllUserDeclarations.Where(declaration => !declaration.IsInspectionDisabled(AnnotationName)); }
+            var annotations = State.GetModuleAnnotations(component).ToList();
+
+            if (State.GetModuleAnnotations(component) == null)
+            {
+                return false;
+            }
+
+            // VBE 1-based indexing
+            for (var i = line - 1; i >= 1; i--)
+            {
+                var annotation = annotations.SingleOrDefault(a => a.QualifiedSelection.Selection.StartLine == i) as IgnoreAnnotation;
+                if (annotation != null && annotation.InspectionNames.Contains(AnnotationName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        protected bool IsInspectionDisabled(Declaration declaration, string inspectionName)
+        {
+            if (declaration.DeclarationType == DeclarationType.Parameter)
+            {
+                return declaration.ParentDeclaration.Annotations.Any(annotation =>
+                    annotation.AnnotationType == AnnotationType.Ignore
+                    && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
+            }
+
+            return declaration.Annotations.Any(annotation =>
+                annotation.AnnotationType == AnnotationType.Ignore
+                && ((IgnoreAnnotation)annotation).IsIgnored(inspectionName));
         }
 
         public int CompareTo(IInspection other)