Is this a bug? +goto

[MatheusBN]

On Tuesday, 6 November 2018 at 05:46:40 UTC, Jonathan M Davis 
wrote:
> On Monday, November 5, 2018 7:55:46 PM MST MatheusBN via 
> Digitalmars-d-learn wrote:
>> On Tuesday, 6 November 2018 at 01:55:04 UTC, Jonathan M Davis
>>
>> wrote:
>> >> And I found a bit strange that in such code, since "x" is 
>> >> never used, why it isn't skipped.
>> >
>> > It's skipped right over. The goto jumps out of the scope, 
>> > and the line with
>> >
>> > int x;
>> >
>> > is never run. In fact, if you compile with -w or -wi, the 
>> > compiler will give you a warning about unreachable code.
>>
>> That is exactly my point.
>>
>> Since "x" it's skipped and never used, it shouldn't just be a 
>> warning (unreachable code) instead of an error?
>>
>> I'm trying to understand why/when such code could give any 
>> problem.
>>
>> On the other hand if the code were:
>>
>> {
>>     goto Q:
>>     int x;
>>
>>     Q:
>>     x = 10; // <- Now you are accessing an uninitialized 
>> variable.
>> }
>>
>> Then I think an error would be ok.
>
> D tries to _very_ little with code flow analysis, because once 
> you start having to do much with it, odds are that the compiler 
> implementation is going to get it wrong. As such, any feature 
> that involves code flow analysis in D tends to be _very_ 
> simple. So, D avoids the issue here by saying that you cannot 
> skip the initialization of a variable with goto. The compiler 
> is not going to do the complicated logic of keeping track of 
> where you access the variable in relation to the goto. That's 
> exactly the sort of thing that might be obvious in the simple 
> case but is highly likely to be buggy in more complex code. 
> Code such as
>
> {
>     goto Q;
>     int x;
> }
> Q:
>
> or
>
> {
>     if(foo)
>         goto Q;
>     int x;
> }
> Q:
>
>
> is fine, because the compiler can trivially see that it is 
> impossible for x to be used after it's been skipped, whereas 
> with something like
>
> goto Q;
> int x;
> Q:
>
> the compiler has to do much more complicated analysis of what 
> the code is doing in order to determine that, and when the code 
> isn't trivial, that can get _really_ complicated.
>
> You could argue that it would be nicer if the language required 
> that the compiler be smarter about it, but by having the 
> compiler be stupid, it reduces the risk of compiler bugs, and 
> most people would consider code doing much with gotos like this 
> to be poor code anyway. Most of the cases where goto is 
> reasonable tend to be using goto from inside braces already, 
> because it tends to be used as a way to more efficiently exit 
> deeply nested code. And with D's labeled break and continue, 
> the need for using goto outside of switch statements also tends 
> to be lower than it is in C/C++.
>
> - Jonathan M Davis

It's clear now about this decision and by the way thanks for 
replying all my doubts.

MatheusBN.