Accept <inheritdoc />

[boop5]

Issue: R# throws a warning at me, saying that an exception is not documented. Although it's already documented in the corresponding interface. This already should be enough - IMHO.

Although - if I use the <inheritdoc /> tag it definitely should not throw a warning around. Right?

Here my simplified code broken down to the important parts.

/// <inheritdoc />
[Serializable]
public sealed class CantMoveForwardException
{
    public CantMoveForwardException(){}
    public CantMoveForwardException(string message) : base(message){}
    public CantMoveForwardException(string message, Exception innerException) : base(message, innerException){}
}

public interface IMyService
{
    /// <summary> ... </summary>
    /// <exception cref="CantMoveForwardException"> ... </exception>
    void MoveForward();
}

public class MyService : IMyService
{
    /// <inheritdoc />
    public void MoveForward()
    {
        if (!CanMoveForward)
        {
            throw new CantMoveForwardException("Can not move forward.");
        }

        _beforeCurrent.Push(Current);
        Current = _afterCurrent.Pop();
    }
}

[Tsanas]

Pretty essential...

[jamesmcguirepro]

I agree, this is a pretty big gap 😞

[jamesmcguirepro]

Looks the same as #26, #32, and #65

[ManticSic]

I'll look at it as soon as possible

[ManticSic]

What do you expect, how should Exceptional behave?

Simple solution
Ignoring any methods using /// <inheritdoc />

More complex solution
Checking the parents documentation if the exception is already documented.

• If not: highlight the expression and provide catch quickfix
• If not: highlight the expression (and provide documentation quickfix (could be hard to be implement, because the parent type can be outside the project))

Checking the parents documentation if all documented exceptions are thrown.

• If not: highlight the method

[jamesmcguirepro]

I think Exceptional should checking the parent's documentation.

If the parent type is outside the project, I wouldn't expect to be able to do a quickfix on the parent type. However, it'd be nice to maintain the ability to quickfix the implementation's documentation.

[JeremyMorton]

A quickfix could be provided for the parent documentation (if it's a source file that is modifiable, as opposed to just in an external assembly that isn't built from the solution), as well as another quickfix that adds the documentation to this implementation, since you can provide more documentation tags after /// <inheritdoc /> which will add or override documentation.