sergeyteplyakov/exceptionanalyzer

Roslyn-based analyzer for exception handling best practices

exceptionanalyzer's Issues

Warn for empty catch block

But only for catch {} and catch(Exception) {}.

This is a very simple warning with a fix that adds throw;.

Warn if-throw argument validation in iterator block

Don't know about quick fix: method should be splitted in two (or switched to Contract.Requires)

Warn if catched exception is not used as inner exception

Warn if try block uses `task.Result` but `AggregateException` does not catched

Quick fix could be: replace with GetAwaiter().GetResult().

Minor spelling issue in readme

On both nuget.org: https://www.nuget.org/packages/ExceptionAnalyzer/

and in the README.md, exception is spelled as "excpetion" in a few places.

Supported?

Hi Sergey,
I'm started making something like that https://github.com/leotsarev/hardcode-analyzer/tree/master/Tsarev.Analyzer.Exceptions
and after that I stumbled upon your project.
Will you willing to accept some pull requests and package your analyzer for Nuget.org?
Appveyor is free-of-charge solution to CI for open source C#.

Add build targets that will public nuget and VSIX packages

VS2017 support

Would be nice to have this tool in VS2017.

Warn if catch block is generic (catch or catch(Exception)) but try block is huge

Remove warning on unreachable return statements

Tool should not warn for this code:

public int Foo(int n)
{
    try
    {}
    catch(Exception)
    {
        throw;
        return 42; // <----
    }
    return 42;
}

Warn when exception could be swallowed

Especially for generic exceptions such as Exception, ApplicationException etc.

Warn when base exception type is `ApplicationException`

Quick fix: replace with System.Exception.

Adding Exception ex could break a tree

For this input:

try {}
catch //foo
{}

Current version incorrectly transforms to:

try {}
catch //foo
(Exception ex)
{}

Warn for throwing ApplicationException

ApplicationException considered useless.

Add missing <exception> rule

In most simple form the rule can tell that the method throws, in more advanced form analyzer can deal with current class and suggest attributes for public methods even when private methods throw.

THere is no way to look deeper, but even in those cases the rule could be useful.

Warn for catch without rethrow

void Foo()
{
  try { Console.WriteLine();}
  catch {Console.WriteLine();}
}

Possible quick fixes:

1. Add Exception e
2. Add throw;

Warn for writing only ex.Message

Quick fix: ex.Message.

Especially true for method that swallow exception.

Add icon to the nuspec and VSIX

Warn if try block has `task.Wait` but `catch(AggregateException)` is missing

Warn for throw ex;

Quick fix: remove ex;

Swallowing exceptions with logging

Consider following scenario:

catch (SomethingException ex) {
   log.Error(ex);
   return false;
}

Why do you mark this as error? If exception already observed & logged, why this is a smell?

Warn for if-throw in async method

Quick fix should be the same as for iterator blocks.

Pseudo checked exceptions

Don't know is it possible to implement! But would be good to try!

Warn for `catch` blocks

Fix: add exception type name.