compiler-warnings | A list of compiler warning flags for different GCC and clang versions | Compiler library

Where are the NVCC codes for a specific warning listed?

They are not publicly available. There is no list. There is no straightforward way of doing what you want without some combination of:

1. Promoting all warnings to errors and forcing the device front end/compiler to emit error codes not textual messages, and then
2. Snooping around in the EDG front end documentation and the files and documented distributed by other compilers which also use the EDG front end to see if you can find a matching code, otherwise
3. Dumping strings and snooping around in the cudafe executable to see if you can find the string you are looking for, and then see if you can reverse engineer back to a warning code or enumeration

In short, you really have to want this badly and have time to invest, and even then it might not be possible.

Alternatively, register in the NVIDIA developer program, raise a bug and see if they will help you with the information you need.

[...] it does not even enter the function.

That's true, because num2 = -2, the string "Your base num less than zero" is thrown but it's not caught, throwing strings around is not something one would recommend. I suggest you wrap it in an actual exception and throw it instead.

The conditions will be as follows:

Templated return types need to be wrapped in (...). This is explained in: Q. Why can't I mock a function that returns a template?

Found a working solution. It turns out the relevant flag is actually "SDL checks", not "Treat Warnings as Errors". Flipping it from /sdl to /sdl- causes compilation to emit a warning while still compiling.

EDIT: If I want to keep all the SDL checks on except treating Warning C4996 as an error, I can use the flag /sdl in combination with the flag /w34996, which specifies that 4996 is treated as a level 3 warning instead of an error.

There is an (apparently) undocumented warning C4388 that will be shown for your code, which is very similar to the documented C4389.

The following code, compiled with the /W4 switch generates each of these two warnings:

This is not possible as a general solution (a custom analyzer can be written for specific cases though, such as your OfType example).

It's also not necessary though. The compiler error in your first example prevents a runtime InvalidCastException, and in your second example the warning indicates a predicate that's always false, and therefore any code in that if statement is unreachable - usually not the intent.

The OfType call has no possibility of a runtime failure. While there may be a minor performance benefit in your OfType example (as the check will invariably return an empty enumeration), since LINQ is lazily evaluated, the real performance benefit would be very minor, if any; but the requirement for the compiler to understand the method's innner workings to accomplish such task, is ...insanely hard to implement correctly! Compilers, even really advanced ones today, haven't learned to do that.

So, not possible, but that might be ok.

Are compilers allowed to support a feature, that is removed in the standard?

The standard doesn't allow that. AFAIK in general it doesn't give any special treatment to features that used to be in the language (doesn't separate them from non-existent features).

If a compiler doesn't diagnose this error (i.e. doesn't give an error or a warning) with a specific configuration (i.e. specific flags), then it doesn't conform to the standard in that configuration.

For what purpose?

Backward compatibility (what else could it be). More specifically, it lets you use both old and new features in a same translation unit.

This can be useful if you're using a library that uses a removed feature in its headers, but want to use the new language features in your own code.

Or if you want to use the removed feature in your own code along with the new features, for some reason.

Note that absolute conformance to the standard is not practically possible to achieve.

Some compiler vendors care about conformance more than the others. Microsoft tends to care less about it (or at least used to, they've been working on that).

The stated warning only persisted as the code was set to compile to the x86 instruction set, in which no more than 4 GB of memory can be used. As in any (and every) case/instance, it is impossible to allocate contiguous memory beyond the range of SIZE_T which makes the range of the size datatype of the x64 architecture wider than that of the x86 (32-bit) architecture.

You can disable this warning right before the line which invokes it and restore it back afterwards https://godbolt.org/z/W-XR-Q: