digitalmars.D - Why is this not a warning?

Shachar Shemesh (16/16) Mar 16 2016 Please consider the following program, which is a reduced version of a

Kagamin (1/1) Mar 16 2016 https://issues.dlang.org/show_bug.cgi?id=259
jmh530 (24/28) Mar 16 2016 Here's a simpler example:
Mathias Lang (17/35) Mar 16 2016 I find integer promotion/comparison rules to be one of the

jmh530 (3/5) Mar 16 2016 I just read Walter's Dr. Dobbs article on VRP:
tsbockman (18/20) Mar 16 2016 Lionello Lunesu did a lot of work both on improving VRP, and on

tsbockman (12/20) Mar 16 2016 While this particular issue can and should be addressed in the

Shachar Shemesh (3/16) Mar 16 2016 I'm afraid that paying run-time cost to verify correctness is out of the...

tsbockman (12/35) Mar 17 2016 You could use the `DebugInt` wrapper. It aliases to `SafeInt` in

Dominikus Dittes Scherkl (56/93) Mar 17 2016 Or you can use an improved opCmp implementation in the compiler,

tsbockman (17/21) Mar 17 2016 For the signed/unsigned comparison problem, specifically - I
tsbockman (19/23) Mar 17 2016 I should also point out that, while it would have been eminently
Basile B (52/54) Mar 17 2016 The compiler could statically fix two cases, ALWAYS without

Basile B (7/40) Mar 17 2016 Obviously I meant to write this:

jmh530 (2/7) Mar 17 2016 Cool. Worth knowing.

Uranuz (15/33) Mar 19 2016 Yep. Integer promotions in D sucks! I like this example:

Shachar Shemesh <shachar weka.io> writes:

Please consider the following program, which is a reduced version of a 
problem I've spent the entire of today trying to debug:

import std.stdio;

void main() {
     enum ulong MAX_VAL = 256;
     long value = -500;

     if( value>MAX_VAL )
         value = MAX_VAL;

     writeln(value);
}

People who are marginally familiar with integer promotion will not be 
surprised to know that the program prints "256". What is surprising to 
me is that this produced neither error nor warning.

The comparable program in C++, when compiled with gcc, correctly warns 
about signed/unsigned comparison (though, to be fair, it seems that 
clang doesn't).

Mar 16 2016

Kagamin <spam here.lot> writes:

https://issues.dlang.org/show_bug.cgi?id=259

Mar 16 2016

jmh530 <john.michael.hall gmail.com> writes:

On Wednesday, 16 March 2016 at 16:40:49 UTC, Shachar Shemesh 
wrote:
 People who are marginally familiar with integer promotion will 
 not be surprised to know that the program prints "256". What is 
 surprising to me is that this produced neither error nor 
 warning.

Here's a simpler example:

import std.stdio : writeln;

void main() {
     ulong MAX_VAL = 256;
     long value = -500;

     writeln(value > MAX_VAL); //prints true
}

Looks like integer promotion in D follows the same rules as C: 
when the types are the same size, the signed type is converted to 
the unsigned type. Definitely could cause an issue and deserves a 
warning, as you say.

It's not like you could switch the rule to being that an unsigned 
type is converted to the signed type. You would still get errors, 
just over a different range. You could instead write something 
like:

bool compare(long a, ulong b)
{
	if (b < long.sizeof)
		return a > cast(long)b;
	else
		return cast(float)a > cast(float)b;
}

Mar 16 2016

Mathias Lang <pro.mathias.lang gmail.com> writes:

On Wednesday, 16 March 2016 at 16:40:49 UTC, Shachar Shemesh 
wrote:
 Please consider the following program, which is a reduced 
 version of a problem I've spent the entire of today trying to 
 debug:

 import std.stdio;

 void main() {
     enum ulong MAX_VAL = 256;
     long value = -500;

     if( value>MAX_VAL )
         value = MAX_VAL;

     writeln(value);
 }

 People who are marginally familiar with integer promotion will 
 not be surprised to know that the program prints "256". What is 
 surprising to me is that this produced neither error nor 
 warning.

 The comparable program in C++, when compiled with gcc, 
 correctly warns about signed/unsigned comparison (though, to be 
 fair, it seems that clang doesn't).

I find integer promotion/comparison rules to be one of the 
messier part of D at the moment. E.g. the compiler won't say 
anything about `ulong foo = -1;` either.
Sadly, to solve that without imposing much pain on the users, you 
need a more decent VRP than we currently have, for example the 
following should compile:

```
void main ()
{
     ushort f;
     uint i;

     if (i < ushort.max)
         f = i;
}
```

Mar 16 2016

jmh530 <john.michael.hall gmail.com> writes:

On Wednesday, 16 March 2016 at 18:39:36 UTC, Mathias Lang wrote:
 Sadly, to solve that without imposing much pain on the users, 
 you need a more decent VRP than we currently have,

I just read Walter's Dr. Dobbs article on VRP:
http://www.drdobbs.com/tools/value-range-propagation/229300211

Mar 16 2016