Add a "WorkInProgress" attribute

[LWChris]

There is the NotImplementedException that also does a good job of suppressing some spurious warnings, like IDE0060 unused parameter:

public static Foo(string bar) => throw new NotImplementedException(); // will not show IDE0060 Unused parameter "bar"

However, it can't help with everything:

public async Task Foo() => throw new NotImplementedException(); // will show CS1998 No await in async method

public void Foo() {
    var bar = GetBar(); // will show CS0219 and IDE0059 Assigned but unused variable/value
    throw new NotImplementedException();
}

I suggest to add a new [WorkInProgress] attribute (e.g. in System.Diagnostics.CodeAnalysis). Its purpose is to be a temporary attribute added to methods that you have outlined or started writing but are not finished writing with yet.

For all methods that have this attribute, we could

• teach the compiler to ignore the linting issues mentioned above as well as others commonly occurring in half-baked code snippets
• automatically list all occurrences on the TODO list
• let a "Release" build fail as long as that attribute is on a method somewhere in the code
• automatically add throw new NotImplementedException() as last statement of the method to get rid of all "not all possible code paths have a return value" warnings in a compileable fashion without having to modify the code

[DaZombieKiller]

This seems more suitable as an analyzer that suppresses CS1998, CS0219 and IDE0059 when the method throws NotImplementedException. I'm not sure what advantage WorkInProgressAttribute would provide over that.

[LWChris]

The advantage of not having to learn how to and then actually do program a whole analyzer, for a start.

But in all seriousness, throwing a NotImplementedException can be a valid final state of code, like NotSupportedException. The idea of WorkInProgressAttribute is to explicitly state that this code is not done and should never be considered "safe to ship" as long as the attribute is there.

Just like the ObsoleteAttribute marks code that is past its shelf life, WorkInProgressAttribute declares code that is not yet ready to ship.

[Joe4evr]

Learning how to write an analyzer will be far more advantageous in the long run, though.

Additionally, if your problem is that you can't launch a quick debug session because your code base sets TreatWarningsAsErrors, then it might suit you to have it set conditionally. (I do this all the time and it works very well.)

<TreatWarningsAsErrors Condition="'$(Configuration)' != 'Debug'">true</TreatWarningsAsErrors>

[LWChris]

Of course, learning how to program is always infinitely more powerful than using an available tool. Yet I'd rather sometimes just use a compiler rather than program one. Not particularly keen on spending an hour to understand the syntax tree classes at the moment. Plus I don't think an analyzer could do stuff like "Add an item to TODO panel" (or maybe it can? I don't know).

[am11]

[Joe4evr]

This isn't about "preview features" and consumers, this is about allowing your own codebase (likely non-public) to build without a bunch of lint-esque warnings on code that's not done yet.

[LWChris]

That is right, I am designing an internal code base and keep migrating code back and forth, drafting methods to test the API usability, etc. But my project is riddled with squiggles from stuff I don't care about, like "can be made readonly", "can be made static", "does not return", "unused parameter", "unused variable", "has no await", "out parameter not set", "readonly parameter not initialized in constructor", "variable assigned but not used", "single statement can be made expression body" etc. etc. etc.

I want a quick way to tell VS to skip all those suggestions and warnings for a moment so I can use the window to find the actual problems that I care about.