Add `Pass ByVal` quick fix to ImplicitByRefModifier inspection

[daFreeMan]

What
The ImplicitByRefModifier does a great job of finding places where the programmer has left out a specific ByRef modifier, and it offers the opportunity to make it explicit. However, there are times when the parameter should have been ByVal, instead, and having the opportunity to make it so with a QucikFix would be quite handy.

Why
Because sometimes a parameter should be ByVal, even when it wasn't specified either way to begin with.

Example
This code should trigger the inspection:

Public Function DoSomething(foo as string)
    DoSomething = foo & "bar"
End Function

---

QuickFixes

1. Pass parameter by value

   Example code, after quickfix is applied:

   Public Function DoSomething(ByVal foo as string)
     DoSomething = foo & "bar"
   End Function

---

Resources
N/A - existing inspection info is sufficient

[BZngr]

The ParameterCanBeByValInspection should flag the example as well.

Offering the option to inject a ByVal modifier (PassParameterByValueQuickFix) within the QuickFix options for ImplicitByRefModifierInspection is possible. But, some of our users may not know when using a ByVal modifier is appropriate. And, since QuickFixes depend upon their associated inspections to pre-check conditions for their execution...using PassParameterByValueQuickFix from the ImplicitByRefModifierInspection may introduce a bug in some scenarios.

So - it may be best to leave the options as they are. If a user elects to inject a ByRef modifier using the PassParameterByReferenceQuickFix, then the ParameterCanBeByValInspection will still flag the opportunity to replace the modifier with ByVal...if it is safe to do so.

[daFreeMan]

then the ParameterCanBeByValInspection will still flag the opportunity to replace the modifier with ByVal...if it is safe to do so.

I would have thought so, as well, but in the particular case that triggered this suggestion, it did not do so (and no, the parameter is not written to - it's only used as a parameter to another called function.

[BZngr]

If the parameter is used as a ByRef parameter in another function, then it is no longer considered a candidate for the ByVal modifier by the ParameterCanBeByValInspection (as currently written). That may be why it did not flag.

Perhaps we need to have an ImplicitParameterMechanismInspection that supports the possibility of either ByRef or ByVal injections when the parameter mechanism is implicit. This would replace the ImplicitByRefModifierInspection which (by its name) assumes injecting the ByRef parameter mechanism is the best solution.

[daFreeMan]

In this particular case, the actual code was:

Private Declare PtrSafe Function GetDriveType Lib "kernel32" Alias "GetDriveTypeA" (ByVal nDrive As String) As Long

Private Function DriveType(DriveLetter As String) As Long
   DriveType = GetDriveType(Left$(DriveLetter, 1) & ":\")
End Function

There is no indication that kernel32.GetDriveTypeA is side-effecting, however you may be correct.