Implicit Type Conversions Warning

[Richard Falk <RichardFalk at comcast dot net>]

I used to use the CodeWarrior compiler on Mac OS 9 and X and then switched
to the GCC compiler.  One set of warnings that I sorely miss is that of
implicit type conversions.  GCC does offer a ³-Wconversion² warning, but
this warns against type conversions between types in a function prototype
vs. types that would be used if the prototype is missing.  This is clearly a
warning for historical purposes before C++ required function prototypes (and
for C one can use ­Wstrict-prototypes, ­Wmissing-prototypes and
­Wmissing-declarations).  What I desire is a warning for implicit type
conversions between the passed parameter and the function prototype for that
parameter.  The current ³-Wconversion² implicit parameter types for missing
function prototypes warning is irrelevant if one requires function
prototypes (as C++ does or as one can catch from the ³C² warnings just
mentioned).

The ³-Wconversion² also warns against signed constant to unsigned variable
conversion (assignment).  This is incomplete.  What I desire is a warning
for implicit type conversions in an assignment and would apply to assignment
from a variable or expression, not just from a constant.

Though there are many ways one can categorize implicit type conversions, the
following are useful and would apply to both function arguments vs. function
prototype parameters and to assignments:

- Signed/Unsigned conversions.  These are from a signed type to an unsigned
type and vice versa.  Unspecified types, such as ³int², are treated by their
implied signed type (³char² is treated as signed or unsigned based on the
machine unless ­funsigned-char or ­fsigned-char is specified).

- Shortened conversions.  These are from a larger type to a shorter type.
For example, from ³long² to ³short² or from ³double² to ³float² or from
³float² to ³int².  The size of an ³int² is based on the machine.  Since
³signed/unsigned conversions² is a separate warning, this ³shortened
conversions² warning would not warn about signed/unsigned conversions that
did not go from a larger type to a shorter type.  So, ³short² to ³unsigned
short² or ³short² to ³unsigned long² would not generate a warning from
³shortened conversions² (but would for ³signed/unsigned conversions² if that
warning was enabled).

- Any conversion.  This would add lengthened and equivalent conversions to
those above.  For example, from ³short² to ³long² or from ³int² to ³long²
(even if ³int² is the size of a ³long² on the machine).  This category also
catches conversions from ³char² to ³signed char² or ³unsigned char² or vice
versa since ³char² is machine-dependent.  However, ³int² and ³signed int²,
etc., are not considered to have any implicit conversion possibility since
the language definition requires these to be exactly equivalent (so no
warning is generated when missing a ³signed² except for the ³char² case).

The primary way to avoid these warnings is to use typecasts, when necessary,
for parameters in function calls and for expressions or constants in
assignments.  This forces the programmer to explicitly declare that they
know what they are doing ? that type conversions are occurring and are
intended.  With proper planning, most typecasts are avoided as parameters
and variables are designed with consistent types initially, but when
mismatches occur, they are at least made explicitly clear.  These warnings
have caught many potential problems in the past.

I didn¹t see this sort of enhancement request mentioned in the archives so
that¹s why I¹m adding this now.  Does anyone know why implicit type
conversion warnings aren¹t in GCC already?  Since CodeWarrior had them, I
would assume that they aren¹t that difficult to implement.

Thanks,
Richard Falk