Bug 13010 – Use variable range propagation (VRP) for static assert

This code should work: void testvrp(ubyte l) { immutable int i = l; static assert(i + 1); }

(In reply to Lionello Lunesu from comment #0) > This code should work: > > void testvrp(ubyte l) > { > immutable int i = l; > static assert(i + 1); > } To me the code looks very weird, because: 1. static assert condition is *always* evaluated in compile time. 2. but the expression i + 1 cannot be evaluated at compile time. These items are contradict each other, so I think it should not be compiled. Could you please show me an *actual* use case of this enhancement?

(In reply to Kenji Hara from comment #2) > (In reply to Lionello Lunesu from comment #0) > > This code should work: > > > > void testvrp(ubyte l) > > { > > immutable int i = l; > > static assert(i + 1); > > } > > To me the code looks very weird, because: > > 1. static assert condition is *always* evaluated in compile time. > 2. but the expression i + 1 cannot be evaluated at compile time. > > These items are contradict each other, so I think it should not be compiled. > > Could you please show me an *actual* use case of this enhancement? How do you feel about it when the code is changed to this: void testvrp(ubyte l) { immutable int i = l; static assert(i >= 0); }

(In reply to Lionello Lunesu from comment #3) > How do you feel about it when the code is changed to this: > > void testvrp(ubyte l) > { > immutable int i = l; > static assert(i >= 0); > } Looks not bad. In my thought, the value of i is not known at compile time, but i >= 0 could be determined to true at compile time with VRP. And, it should be handled in const-folding phase. By advancing the thought, compiler will be able to generate "statement is not reachable" warning in else branch of the code. void test(ubyte n) { immutable int i = n; if (i >= 0) // const-folding with VRP will optimize the condition to true. { ... } else { ... } // so the else branch could be determined to "not reachable" }

--- Comment originally from [email protected] --- (In reply to Kenji Hara from comment #4) > By advancing the thought, compiler will be able to generate "statement is > not reachable" warning in else branch of the code. > > void test(ubyte n) > { > immutable int i = n; > if (i >= 0) // const-folding with VRP will optimize the condition to > true. > { ... } > else > { ... } // so the else branch could be determined to "not reachable" > } Looks nice I guess this will generate few nice warnings in Phobos and in D code around.

--- Comment originally from [email protected] --- (In reply to Kenji Hara from comment #4) > By advancing the thought, compiler will be able to generate "statement is > not reachable" warning in else branch of the code. > > void test(ubyte n) > { > immutable int i = n; > if (i >= 0) // const-folding with VRP will optimize the condition to > true. > { ... } > else > { ... } // so the else branch could be determined to "not reachable" > } Such things could be a problem in templates, where the type is different in different instantiations. This causes a warning if you instantiate it with an T=uint: void foo(T)(T n) { if (n >= 0) { /*...*/ } else { /*...*/ } } void main() { foo(1); // OK foo(1u); // Causes a warning }

I'm not sure whether this is worth the added language complexity. Do you have an example for a compelling use case?

(In reply to David Nadlinger from comment #7) > I'm not sure whether this is worth the added language complexity. Do you > have an example for a compelling use case? Statically testing the range of a variable: ubyte u; static assert(u >= 0);

(In reply to Lionello Lunesu from comment #8) This doesn't compile: ubyte x; void main() { immutable int y = x; ubyte z = y; static assert(y >= 0); } But this compiles, so the compiler knows statically y can't be negative: ubyte x; void main() { immutable int y = x; ubyte z = y; } So accepting that static assert seems a small improvement, perhaps it's just a matter of using the variable range knowledge inside static assert.

(In reply to Lionello Lunesu from comment #8) > (In reply to David Nadlinger from comment #7) > > I'm not sure whether this is worth the added language complexity. Do you > > have an example for a compelling use case? > > Statically testing the range of a variable: > > ubyte u; > static assert(u >= 0); 1. That's hardly what I'd call a use case. It's a minimal snippet showing a consequence of the feature, but doesn't tell me why I would ever want to do this in the first place. 2. In this specific case, inspecting the type (isUnsigned) would be enough anyway.

Even this doesn't compile, but it should: void main() { ubyte x; static assert(x >= 0); }

(In reply to David Nadlinger from comment #10) > (In reply to Lionello Lunesu from comment #8) > > (In reply to David Nadlinger from comment #7) > > > I'm not sure whether this is worth the added language complexity. Do you > > > have an example for a compelling use case? > > > > Statically testing the range of a variable: > > > > ubyte u; > > static assert(u >= 0); > > 1. That's hardly what I'd call a use case. It's a minimal snippet showing a > consequence of the feature, but doesn't tell me why I would ever want to do > this in the first place. > > 2. In this specific case, inspecting the type (isUnsigned) would be enough > anyway. Fine: ubyte u; //<a lot of code> static assert(u < 9);

(In reply to Lionello Lunesu from comment #12) > ubyte u; > //<a lot of code> > static assert(u < 9); I don't understand the point of this code.

THIS ISSUE HAS BEEN MOVED TO GITHUB https://github.com/dlang/dmd/issues/18844 DO NOT COMMENT HERE ANYMORE, NOBODY WILL SEE IT, THIS ISSUE HAS BEEN MOVED TO GITHUB