DIP(?) Warning to facilitate porting to other archs

[Jonathan M Davis via Digitalmars-d]

On Thu, 01 May 2014 11:17:09 +0000
Temtaime via Digitalmars-d <digitalmars-d at puremagic.com> wrote:

> Hi everyone.
> I think it's need to have -w64(or other name, offers ?) flag that
> warns if code may not compile on other archs.
>
> Example:
> size_t a;
> uint b = a; // ok on 32 without a warning but fail on 64 with
> error
>
> And on 32 with -w64 it'll be :
> Warning : size_t.sizeof may be greater than 32 bit
>
> What you thinks ?
> Should i create proposal or nobody cares about porting and it's
> useless ?
>
> Any ideas are welcome.

The compiler doesn't even know that size_t exists. It's just an alias in
object_.d. So, it could be fairly involved to get the compiler to warn
about something like this.

And while in some respects, this would be nice to have, I don't think that
it's actually a good idea. IMHO, the compiler pretty much has no business
warning about anything. As far as the compiler is concerned, everything
should be either an error or nothing (and Walter agrees with me on this;
IIRC, the only reason that he added warnings in the first place was as
an attempt to appease some folks). About the only exception would be
deprecation-related warnings, because those are items that aren't currently
errors but are going to be errors. If warnings are in the compiler,
programmers are forced to fix them as if they were errors (because it's
bad practice to leave compiler warnings in your build), and they can actually
affect what does and doesn't compile thanks to the -w flag (which can be
particularly nasty when stuff like template constraints get involved).

Warnings belong in lint-like tools where the user can control what they want
to be warned about, including things that would be useful to them but most
other folks wouldn't care about. So, unless you're suggesting that we make
it an error to assign a value of size_t to a uint, I don't think that it
makes any sense for the compiler to say anything about this, and given the
fact that it doesn't know anything about size_t anyway, it's probably not
particularly reasonable to have the compiler warn about it even if we agreed
that it would be a good idea.

D is ideally suited to writing lint-like tools, and as I understand it, Brian
Schott has written one. I don't know what state it's currently in or what
exactly it can warn you about at this point, but I think that it would be
better to look at putting warnings like this in such a tool than to try and
get it put in the compiler.

- Jonathan M Davis