Goto skips declaration

[Michelle Long]

On Saturday, 3 November 2018 at 20:04:40 UTC, Rubn wrote:
> On Saturday, 3 November 2018 at 03:52:12 UTC, Michelle Long 
> wrote:
>> On Tuesday, 30 October 2018 at 23:31:46 UTC, luckoverthere 
>> wrote:
>>> On Tuesday, 30 October 2018 at 21:21:22 UTC, Michelle Long 
>>> wrote:
>>>>
>>>> You take examples WAY to literal. Sheesh, do you really 
>>>> think life is that simple? Do you need every detail spelled 
>>>> out for things to make sense?
>>>>
>>>> foreach(x; Y)
>>>> {
>>>>     if (something or another which I won't spell out no 
>>>> matter how much you cry)
>>>>         goto Q; // compiler complains here about x
>>>>     int x;
>>>> }
>>>> Q:
>>>>
>>>> There is no reason why the compiler should have a problem 
>>>> with this.. the fact that using brackets around int x; 
>>>> satisfies the compiler proves this.
>>>
>>>
>>> struct Magic
>>> {
>>>     ~Magic()
>>>     {
>>>         writeln("blah");
>>>     }
>>> ]
>>>
>>> void test()
>>> {
>>>     if(cond)
>>>         goto Y;
>>>
>>>     Magic magic;
>>>
>>>     Y:
>>>     writeln("stuff");
>>>
>>>     // calls ~Magic();
>>> }
>>>
>>> You'd need a bunch of extra information to know what is and 
>>> wasn't actually declared and initialized.
>>>
>>> "Putting brackets around it proves it".
>>>
>>> void test()
>>> {
>>>     if(cond)
>>>         goto Y;
>>>
>>>     {
>>>         Magic magic;
>>>
>>>         // calls ~Magic();
>>>     }
>>>
>>>     Y:
>>>     writeln("stuff");
>>>
>>> }
>>>
>>> There is no more conflict with brackets, yes. But expecting 
>>> the compiler to do this changes the behavior of the code. 
>>> Sure if there's no destructor it could work around it, but it 
>>> would complicated code generation. Adding a bunch of time 
>>> looking for these circumstances.
>>>
>>> It's just not worth it, use brackets like you are now or move 
>>> the declarations of your variables up to the top of the scope 
>>> before any gotos. Pretty simple workarounds.
>>
>>
>> You are not understanding the problem. The goto must be in the 
>> same scope as the local variable:
>>
>> {
>>
>>    goto Y;
>>    int x;
>> }
>> Y:
>>
>> The compiler will complain(I'm doing it in a foreach loop) 
>> that x is skipped!!!
>>
>> Do you understand?
>>
>> The goto will always bypass x being declared so it doesn't 
>> matter. The compiler may optimize out the simple case above, 
>> but that is irrelevant to the problem.
>>
>> The problem is simple: The compiler thinks that the declared 
>> variables are used after the goto but it is impossible since 
>> the goto skips out of the block and the local variables cease 
>> to exist.
>>
>> The compiler treats the problem as if it is
>>
>> {
>>     goto Y:
>>     int x;
>>     Y:
>> }
>>
>> and that is a totally different problem. They are not the same 
>> but the compiler treats them the same.
>>
>> In the second case the goto does skip over the declaration, in 
>> the first case it does not. In the second case it is a problem 
>> but in the first case it cannot be.
>>
>> Again, adding the brackets proves it.
>
>
> The problem you describe doesn't exist.
>
> https://run.dlang.io/is/Snpt3l
>
> If that isn't the issue, then actually give a runable source 
> example with the associated error that it produces.

No, the problem actually exists. Simply because a simplified 
example does not produce the result does not mean it doesn't 
exist. The compiler does a lot of things so to suggest that I 
simply fabricated the error because the simplified demonstration 
case does not produce the error as pathetic.

I got this error in my code and I simplified all the crap out of 
it to what I did that produced it and how I remedied it. It's not 
my fault you don't believe me.