ReSharper Curiosity: "Parameter is only used for precondition check(s)."

Question

Why is ReSharper judging me for this code?

    private Control GetCorrespondingInputControl(SupportedType supportedType, object settingValue)
    {
        this.ValidateCorrespondingValueType(supportedType, settingValue);

        switch(supportedType)
        {
            case SupportedType.String:
                return new TextBox { Text = (string)settingValue };
            case SupportedType.DateTime:
                return new MonthPicker { Value = (DateTime)settingValue, ShowUpDown = true };
            default:
                throw new ArgumentOutOfRangeException(string.Format("The supported type value, {0} has no corresponding user control defined.", supportedType));
        }
    }

    private void ValidateCorrespondingValueType(SupportedType supportedType, object settingValue)
    {
        Type type;

        switch(supportedType)
        {
            case SupportedType.String:
                type = typeof(string);
                break;
            case SupportedType.DateTime:
                type = typeof(DateTime);
                break;
            default:
                throw new ArgumentOutOfRangeException(string.Format("The supported type value, {0} has no corresponding Type defined.", supportedType));
        }
        string exceptionMessage = string.Format("The specified setting value is not assignable to the supported type, [{0}].", supportedType);
        if(settingValue.GetType() != type)
        {
            throw new InvalidOperationException(exceptionMessage);
        }
    }

The second method ValidateCorrespondingValueType's "settingValue" parameter is grayed out with the following message by ReSharper: "Parameter 'settingValue' is only used for precondition check(s)."

Cuculiform

You can move the declaration and assignment of exceptionMessage into the if-block :) – Aeriel

You could also do this in the method: expectedText += ""; and it stops complaining since you used it in the method. – Brocatel

Answer 1

It's not judging, it's trying to help :)

If ReSharper sees that a parameter is only used as a check to throw an exception, it greys it out, indicating that you're not actually using it for "real" work. This is most likely a mistake - why pass in a parameter you're not going to use? It usually indicates that you've used it in a pre-condition, but then forgotten (or no longer need) to use it elsewhere in the code.

Since the method is an assertion method (that is, all it does is assert it's valid), you can suppress the message by marking the ValidateCorrespondingValueType as an assertion method, using ReSharper's annotation attributes, specifically the [AssertionMethod] attribute:

[AssertionMethod]
private void ValidateCorrespondingValueType(SupportedType supportedType, object settingValue)
{
  // …
}

Trucker

It's a nice check, but in this case R# has over-reached a bit, wouldn't you say? The check on settingValue's type can't possible be a pre-condition, since the thing it's being checked against isn't known until some work has been done within the body of the method! – Aeriel

That's why you need to tell ReSharper it's an assertion method. The sole point of this method is to perform the pre-condition check for another method. It's an assert, but ReSharper can't know that unless you tell it with [AssertionMethod]. – Trucker

I don't see AssertionMethod on the page you linked to and when I try to add it in code ReSharper isn't helping me out with using statements. What assembly and namespace is that attribute in? – Linctus

I ended up just changing the Inspection Severity to "Do Not Show", this is another option. – Linctus

Oh yeah, I didn't realise it's not on the page. Funnily enough, it's not in the default implementation that ReSharper 8 provides via the annotations options page, either. I think it was going to be phased out, in favour of [ContractAnnotation] which does the same thing, but is more versatile. However, phasing it out breaks old code. Either way, it's in the current version of the official annotations nuget package, with xml docs. – Trucker

It might have been a useful feature, if one could disable the 'pre-condition only' inspection independently from the regular unused parameter inspection; as it stands the inspection mixes up two issues of different severity and generally makes this functionality useless in certain situations. I'm also very sceptical of the idea of adding comments or attributes to the code just to keep a source code analysis tool happy, so at the moment I don't think there's a satisfactory solution to the issue. – Lemar

It might be trying to help but it's too aggressive. Now, if you verify the value and then never use it, fine, that's likely an error. However, it's yapping at me over one where I only use the value in the error. How else can that be anything but intentional? – Permission

I began to scoff about a package that I need to include and production-package to aid in development only, but then I learned that the Attribute is conditional-compiled with JETBRAINS_ANNOTATIONS, so it won't make its way into the assembly unless you explicitly declare that symbol. So: Thanks for the tip with the attribute, I explore its possibilities :) – Trucking

Yep, the package doesn't require a binary dependency, unless you define JETBRAINS_ANNOTATIONS. You can also include the source directly in your code, so you still get the annotations, your users get the annotations, and you don't take a binary dependency. See this blog post for more details. – Trucker

@LorenPechtel, I notice that if you use the new 'nameof' functionality in C#6 to specify the name of the argument passed in when throwing, say, an ArgumentNullException', then ReSharper backs off. – Picoline

@Picoline Seems like a bug in ReSharper, since that inspection should still apply in that case. – Moritz

I'm going to accept this an answer for opening insightful dialogue. – Cuculiform

I don't like to add another component to my solution just for the sake of the message – Continence

So, if I have a parameter bool requiredResult and it's true value tells the method to throw an exception if method is about to return a null is it still an [AssertionMethod]? I doubt it... or do I have a design problem here? :) Funny thing is, if I have a silly statement above throw which builds an exception message, all's good from Resharper. – Surprise

Answer 2

Interestingly, ReSharper backs off if you use the new nameof functionality in C#6:

static void CheckForNullParameters(IExecutor executor, ILogger logger)
{
    if (executor == null)
    {
        throw new ArgumentNullException(nameof(executor));
    }

    if (logger == null)
    {
        throw new ArgumentNullException(nameof(logger));
    }
}

Picoline

this answer suits me, it is less intrusive than adding a nuget package – Continence

Answer 3

The following fixes the issue (in ReSharper 2016.1.1, VS2015), but I am not sure it solves the 'right' problem. In any case, it shows the ambiguity in ReSharper's mechanics regarding this topic:

This yields the warning:

    private void CheckForNull(object obj)
    {
        if (ReferenceEquals(obj, null))
        {
            throw new Exception();
        }
    }

But this does not:

    private void CheckForNull(object obj)
    {
        if (!ReferenceEquals(obj, null))
        {
            return;
        }
        throw new Exception();
    }

It is interesting that equivalent code (the inversion was done by ReSharper :D) gives different results. It seems that the pattern matching simply does not pick up the second version.

Aprylapse

Answer 4

My preferred solution to this problem is make resharper think the parameter is used. This has an advantage over using an attribute such as UsedImplicitly because if ever you do stop using that parameter, resharper will start warning you again. If you use an attribute, resharper won't catch future real warnings either.

An easy way to make resharper think the paramter is used is by replacing throw with a method. So instead of...

if(myPreconditionParam == wrong)
    throw new Exception(...);

...you write:

if(myPreconditionParam == wrong)
    new Exception(...).ThrowPreconditionViolation();

This is nicely self-documenting for future programmers, and resharper quits whining.

The implementation of ThrowPreconditionViolation is trivial:

public static class WorkAroundResharperBugs 
{
    //NOT [Pure] so resharper shuts up; the aim of this method is to make resharper 
    //shut up about "Parameter 'Foobaar' is used only for precondition checks" 
    //optionally: [DebuggerHidden]
    public static void ThrowPreconditionViolation(this Exception e)
    {
        throw e;
    }
}

An extension method on Exception is namespace pollution, but it's fairly contained.

Tutorial

+1 for mentioning [UsedImplicitly], I didn't want to use [AssertionMethod] as it wasn't, and used implicitly sounds more accurate it in my case (I was passing a value to a callback in a constructor and returning the constructed object). – Reviewer

Answer 5

Others have already answered the question, but no one mentioned the following ways of turning off the warning.

Add this above the method signature to turn it off for only that method:

    // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local

Add this above the class declaration to turn it off for the entire file:

     // ReSharper disable ParameterOnlyUsedForPreconditionCheck.Local

Burbot

A disadvantage is that you can not specify witch parameter you mean. – Tessera

@Tessera You can disable for a single parameter by using disable and restore comments around that particular parameter. I'd suggest putting every parameter on its own line in that case; still ugly but less so (in my opinion). – Examinee

Answer 6

I believe below is a legit case where I check all items in list with lambda Any method. Then I use the same way the next line but resharper fails.

if (actions.Any(t => t.Id == null)) // here says Paramter t is used only for precondition check(s)
    throw new Exception();
actionIds = actions.Select(t => t.Id ?? 0).ToList();

I had to ignore with comment.

Lollard

Answer 7

use this comment above parameter

// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local

to disable suggestion in Rider

Affairs