Merge pull request #5652 from BZngr/5628_MisleadingByRefFalsePositive

Fix  MisleadingByRefParameterInspection false positive: array parameters

Author: retailcoder

Rubberduck.CodeAnalysis/Inspections/Concrete/MisleadingByRefParameterInspection.cs

@@ -13,17 +13,17 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// <why>
     /// Regardless of the presence or absence of an explicit ByRef or ByVal modifier, the value-parameter
     /// of a property mutator is always treated as though it had an explicit ByVal modifier.
-    /// Exception: UserDefinedType parameters are always passed by reference.
+    /// Exception: UserDefinedType and Array parameters are always passed by reference.
     /// </why>
     /// <example hasResult="true">
     /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Private fizzField As Long
     /// Public Property Get Fizz() As Long
-    ///     Fizz = fizzFiled
+    ///     Fizz = fizzField
     /// End Property
     /// Public Property Let Fizz(ByRef arg As Long)
-    ///     fizzFiled = arg
+    ///     fizzField = arg
     /// End Property
     /// ]]>
     /// </module>
@@ -33,10 +33,10 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// <![CDATA[
     /// Private fizzField As Long
     /// Public Property Get Fizz() As Long
-    ///     Fizz = fizzFiled
+    ///     Fizz = fizzField
     /// End Property
     /// Public Property Let Fizz(arg As Long)
-    ///     fizzFiled = arg
+    ///     fizzField = arg
     /// End Property
     /// ]]>
     /// </module>
@@ -50,14 +50,18 @@ public MisleadingByRefParameterInspection(IDeclarationFinderProvider declaration
         protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
         {
             return declaration is ParameterDeclaration parameter
-                && !(parameter.AsTypeDeclaration?.DeclarationType.HasFlag(DeclarationType.UserDefinedType) ?? false)
-                && parameter.ParentDeclaration is ModuleBodyElementDeclaration enclosingMethod
+                && !IsAlwaysByRef(declaration)
+                && declaration.ParentDeclaration is ModuleBodyElementDeclaration enclosingMethod
                 && (enclosingMethod.DeclarationType.HasFlag(DeclarationType.PropertyLet)
                     || enclosingMethod.DeclarationType.HasFlag(DeclarationType.PropertySet))
                 && enclosingMethod.Parameters.Last() == parameter
                 && parameter.IsByRef && !parameter.IsImplicitByRef;
         }
 
+        private static bool IsAlwaysByRef(Declaration parameter) 
+            => parameter.IsArray
+                || (parameter.AsTypeDeclaration?.DeclarationType.HasFlag(DeclarationType.UserDefinedType) ?? false);
+
         protected override string ResultDescription(Declaration declaration)
         {
             return string.Format(

RubberduckTests/Inspections/MisleadingByRefParameterInspectionTests.cs

@@ -54,6 +54,31 @@ End Property
             Assert.AreEqual(0, InspectionResultsForStandardModule(inputCode).Count());
         }
 
+        //https://github.com/rubberduck-vba/Rubberduck/issues/5628
+        [TestCase("ArrayToStore")]
+        [TestCase("ByRef ArrayToStore")]
+        [Category("QuickFixes")]
+        [Category(nameof(MisleadingByRefParameterInspection))]
+        public void ArrayEdgeCase(string parameterMechanismAndParam)
+        {
+            var inputCode =
+$@"
+Option Explicit
+
+Private InternalArray() As Variant
+
+Public Property Get StoredArray() As Variant()
+    StoredArray = InternalArray
+End Property
+
+Public Property Let StoredArray({parameterMechanismAndParam}() As Variant)
+    InternalArray = ArrayToStore
+End Property
+";
+
+            Assert.AreEqual(0, InspectionResultsForStandardModule(inputCode).Count());
+        }
+
         [Test]
         [Category("QuickFixes")]
         [Category(nameof(MisleadingByRefParameterInspection))]