<div dir="ltr">It is, but there are limits to what it can do.<div>D's contracts potentially offer a lot of information that the optimiser wouldn't naturally have (any function receiving blind arguments can't make any assumptions without a contract present), but more from a usability/safety point of view, I really hate casting when the compiler should know the assignment is safe.</div>
<div style><br></div><div style>It's not only an inconvenience, it's also a safety thing.</div><div style>Consider:</div><div style>I have an int that I assign to a byte, I know the value fits in a byte, but I'm forced to type the manual cast anyway.</div>
<div style>Once that cast is written, if the valid range of my int happens to change in outer code, I will not receive an error informing me that the new range doesn't fit within a byte anymore, it'll just truncate it anyway, since a blind cast is already there in the code.</div>
<div style>It would be much better for the compiler to start complaining that it can no longer assure that the int fits into the byte. With the cast present, my bug has been hidden until I eventually crash.</div></div><div class="gmail_extra">
<br><br><div class="gmail_quote">On 13 May 2013 10:18, John Colvin <span dir="ltr"><<a href="mailto:john.loughran.colvin@gmail.com" target="_blank">john.loughran.colvin@gmail.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
<div class="HOEnZb"><div class="h5">On Monday, 13 May 2013 at 00:00:54 UTC, Manu wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
So, here's an issue that constantly drives me nuts, and an elegant solution<br>
seems so do-able.<br>
<br>
void func(int x)<br>
{<br>
  x &= 0xFFFF;<br>
  short s = x; // Error! (but we know x is 0 .. 65535)<br>
<br>
  if(x < 256)<br>
  {<br>
    byte b = x; // Error! (we also know x is 0 .. 255)<br>
  }<br>
}<br>
<br>
It would be really nice if the compiler would carry around the known<br>
possible range of values, and refer to that information when performing<br>
down-casting assignments.<br>
It would also be very useful information for the back end, it can choose<br>
more efficient types if it knows the range, or produce jump tables rather<br>
than branch sequences.<br>
<br>
I think the compiler would need a min, max, and mask for any integers, and<br>
update them as it works.<br>
<br>
There are many sources of this information.<br>
Comparisons effectively limit the range:<br>
if(x > 0)<br>
{<br>
  // x = 0 .. int.max<br>
}<br>
else<br>
{<br>
  // x = int.min .. -1<br>
}<br>
<br>
Masks, obviously:<br>
x &= 15;<br>
<br>
Also contracts are a really great source of seeding this information on<br>
function entry.<br>
<br>
Has this been discussed? It seems simple, and it's invisible to the<br>
language. It would just reduce some boilerplate (tedious casts), and also<br>
offer some great optimisation opportunities.<br>
</blockquote>
<br></div></div>
I've been thinking about this for a while from an optimisation point of view. Is this not a common practice for an optimising compiler?<br>
</blockquote></div><br></div>