Merge branch 'next' of https://github.com/rubberduck-vba/Rubberduck into MiscBugFixes2

Author: bclothier

Rubberduck.CodeAnalysis/Inspections/Abstract/QuickFixBase.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using NLog;
 using Rubberduck.Parsing.Inspections.Abstract;
@@ -24,17 +25,28 @@ public void RegisterInspections(params Type[] inspections)
         {
             if (!inspections.All(s => s.GetInterfaces().Any(a => a == typeof(IInspection))))
             {
-#if DEBUG
-                throw new ArgumentException($"Parameters must implement {nameof(IInspection)}", nameof(inspections));
-#else
+                var dieNow = false;
+                MustThrowException(ref dieNow);
+                if (dieNow)
+                {
+                    throw new ArgumentException($"Parameters must implement {nameof(IInspection)}",
+                        nameof(inspections));
+                }
+
                 inspections.Where(s => s.GetInterfaces().All(i => i != typeof(IInspection))).ToList()
                     .ForEach(i => Logger.Error($"Type {i.Name} does not implement {nameof(IInspection)}"));
-#endif
             }
 
             _supportedInspections = inspections.ToHashSet();
         }
 
+        // ReSharper disable once RedundantAssignment : conditional must be void but we can use ref
+        [Conditional("DEBUG")] 
+        private static void MustThrowException(ref bool dieNow)
+        {
+            dieNow = true;
+        }
+
         public void RemoveInspections(params Type[] inspections)
         {
             _supportedInspections = _supportedInspections.Except(inspections).ToHashSet();

Rubberduck.CodeAnalysis/Inspections/Concrete/ArgumentWithIncompatibleObjectTypeInspection.cs

@@ -21,7 +21,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
 	/// <why>
 	/// The VBA compiler does not check whether different object types are compatible. Instead there is a runtime error whenever the types are incompatible.
 	/// </why>
-	/// <example hasResult="true">
+	/// <example hasresult="true">
 	/// <![CDATA[
 	/// IInterface:
 	///
@@ -49,7 +49,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
 	/// End Sub
 	/// ]]>
 	/// </example>
-	/// <example hasResult="false">
+	/// <example hasresult="false">
 	/// <![CDATA[
 	/// IInterface:
 	///

Rubberduck.CodeAnalysis/Inspections/Concrete/DefaultMemberRequiredInspection.cs

@@ -15,7 +15,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// <why>
     /// The VBA compiler does not check whether the necessary default member is present. Instead there is a runtime error whenever the runtime type fails to have the default member.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Class1:
     ///
@@ -34,7 +34,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Class1:
     ///

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitDefaultMemberAccessInspection.cs

@@ -14,31 +14,31 @@ namespace Rubberduck.Inspections.Concrete
     /// Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made
     /// and can cause errors in which a member was forgotten to be called to go unnoticed.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As ADODB.Field)
     ///     Dim bar As Variant
     ///     bar = arg
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As ADODB.Connection)
     ///     Dim bar As String
     ///     arg = bar
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As ADODB.Field)
     ///     Dim bar As Variant
     ///     bar = arg.Value
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As ADODB.Connection)
     ///     Dim bar As String

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitRecursiveDefaultMemberAccessInspection.cs

@@ -14,7 +14,7 @@ namespace Rubberduck.Inspections.Concrete
     /// Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made
     /// and the final default member is not on the interface of the object itself. In particular, this can cause errors in which a member was forgotten to be called to go unnoticed.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <module name="Class1" type="Class Module">
     /// <![CDATA[
     /// Public Function Foo() As Class2
@@ -40,7 +40,7 @@ namespace Rubberduck.Inspections.Concrete
     /// ]]>
     /// </module>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <module name="Class1" type="Class Module">
     /// <![CDATA[
     /// Public Function Foo() As Class2

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitUnboundDefaultMemberAccessInspection.cs

@@ -17,29 +17,29 @@ namespace Rubberduck.Inspections.Concrete
     /// and if the default member cannot be determined from the declared type of the object. As a consequence, errors in which a member was forgotten to be called can go unnoticed
     /// and should there not be a suitable default member at runtime, an error 438 'Object doesn't support this property or method' will be raised.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As Object)
     ///     Dim bar As Variant
     ///     bar = arg
     /// End Sub
     /// ]]>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As Object)
     ///     Dim bar As Variant
     ///     arg = bar
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As Object)
     ///     Dim bar As Variant
     ///     bar = arg.SomeValueReturningMember
     /// End Sub
     /// ]]>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As Object)
     ///     Dim bar As Variant

Rubberduck.CodeAnalysis/Inspections/Concrete/IndexedDefaultMemberAccessInspection.cs

@@ -14,15 +14,15 @@ namespace Rubberduck.Inspections.Concrete
     /// <why>
     /// An indexed default member access hides away the actually called member.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal coll As Collection)
     ///     Dim bar As Variant
     ///     bar = coll(23)
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal coll As Collection)
     ///     Dim bar As Variant

Rubberduck.CodeAnalysis/Inspections/Concrete/IndexedRecursiveDefaultMemberAccessInspection.cs

@@ -14,15 +14,15 @@ namespace Rubberduck.Inspections.Concrete
     /// <why>
     /// An indexed default member access hides away the actually called member. This is especially problematic if the corresponding parameterized default member is not on the interface of the object itself.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal rst As ADODB.Recordset)
     ///     Dim bar As Variant
     ///     bar = rst("MyField")
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal rst As ADODB.Recordset)
     ///     Dim bar As Variant

Rubberduck.CodeAnalysis/Inspections/Concrete/IndexedUnboundDefaultMemberAccessInspection.cs

@@ -17,15 +17,15 @@ namespace Rubberduck.Inspections.Concrete
     /// An indexed default member access hides away the actually called member. This is especially problematic if the default member cannot be determined from the declared type of the object.
     /// Should there not be a suitable default member at runtime, an error 438 'Object doesn't support this property or method' will be raised.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal rst As Object)
     ///     Dim bar As Variant
     ///     bar = rst("MyField")
     /// End Sub
     /// ]]>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal rst As Object)
     ///     Dim bar As Variant

Rubberduck.CodeAnalysis/Inspections/Concrete/ObjectWhereProcedureIsRequiredInspection.cs

@@ -20,7 +20,7 @@ namespace Rubberduck.Inspections.Concrete
     /// Providing an object where a procedure is required leads to an implicit call to the object's default member.
     /// This behavior is not obvious, and most likely unintended.
     /// </why>
-    /// <example hasResult="true">
+    /// <example hasresult="true">
     /// <module name="Class1" type="Class Module">
     /// <![CDATA[
     /// Public Function Foo() As Long
@@ -37,7 +37,7 @@ namespace Rubberduck.Inspections.Concrete
     /// ]]>
     /// </module>
     /// </example>
-    /// <example hasResult="false">
+    /// <example hasresult="false">
     /// <module name="Class1" type="Class Module">
     /// <![CDATA[
     /// Public Function Foo() As Long