"Maybe" assignment failing on struct initilization

[xzores]

Context

This was talked about at: https://discord.com/channels/568138951836172421/568871298428698645/1264674940611858482

Observe the following code:

state = {
        active_elements = make(map[Element]Element_container),
        gui_pipeline = render.pipeline_make(render.get_default_shader(), .blend, false, false),
        default_style = {
            default = default_appearance,
            hover = default_appearance,
            active = default_appearance,
        },
    }
    
    fmt.printf("default_style : %#v\n", state.default_style);
    assert(state.default_style.hover != nil); //This assertion fails.

The assertion failes.
Now observe the following code:

    state = {
        active_elements = make(map[Element]Element_container),
        gui_pipeline = render.pipeline_make(render.get_default_shader(), .blend, false, false),
        default_style = {
            default = default_appearance,
            hover = default_appearance,
            active = default_appearance,
        },
    }
    
    fmt.printf("default_style : %#v\n", state.default_style);
    state.default_style.hover = default_appearance; //This makes the bug go away.
    assert(state.default_style.hover != nil); //This assertion no longer fails.

The assertion no longer failes.

Odin version:
Odin: dev-2024-07-nightly:b4ca044
OS: Windows 11 Home Basic (version: 23H2), build 22631.3880
CPU: 13th Gen Intel(R) Core(TM) i9-13900HX
RAM: 32507 MiB
Backend: LLVM 17.0.1

Expected Behavior

I would expect that the first assertion did not fail.

Current Behavior

The first assertions fails.

Failure Information (for bugs)

I think this is a bug with "Maybe", it seems to not get assigned.

Steps to Reproduce

I have not been able to reproduce this is a simple setup. See "things tested" for more info.
To find a example which failes go to: https://github.com/xzores/furbs/tree/Bug_found
Download and Run the project, it should fail.

things tested

I have tested the following which DID work as expected:

        Temp :: struct {
	        a : int,
	        b : Maybe(int),
        }

	t : Temp = {
		a = 5,
		b = 5,
	}
	
	assert(t.b == 5, "b was not 5");

I have also tried:

Temp3 :: struct {
	e : int,
}

Temp2 :: struct {
	c : int,
	d : Maybe(Temp3),
}

Temp :: struct {
	a : int,
	b : Maybe(Temp2),
}

	t : Temp = {
		a = 5,
		b = Temp2{
			5,
			Temp3{
				5,
			},
		},
	}
	
assert(t.b != nil, "failed");
	
	if t2, ok := t.b.?; ok {
		assert(t.b != nil, "failed2");
		
		if t3, ok := t2.d.?; ok {
			assert(t3.e == 5, "failed3");
		}
	}

I have also tried:

Temp4 :: struct {
	e : int,
}

Temp3 :: union {
	Temp4,
}

Temp2 :: struct {
	c : int,
	d : Maybe(Temp3),
}

Temp :: struct {
	a : int,
	b : Maybe(Temp2),
}

	t : Temp = {
		a = 5,
		b = Temp2{
			5,
			Temp4{
				5,
			},
		},
	}
	
	assert(t.b != nil, "failed");
	
	if t2, ok := t.b.?; ok {
		assert(t.b != nil, "failed2");
		
		if t3, ok := t2.d.?; ok {
		
			assert(t3.(Temp4).e == 5, "failed3");
		}
	}
	

ALL OF THIS PASSED, so I have been unable to replicate the bug in a simpler setup.

[laytan]

Can you give us some code that triggers the assert in your linked repo, like a main proc that calls the procedure that asserts in it?

[xzores]

You will find it in regui/GUI.odin and then in the init function.

[laytan]

Yes but just putting a main proc that imports and calls that doesn't work and fails with errors about a missing package ex_defs

[laytan]

Ok got it down to this repro:

package bug

Bar :: union {
	int,
}

Foo :: union {
	Bar,
}

FooBar :: struct {
	foo: Foo,
}

main :: proc() {
	foo := FooBar {
		foo = 69, // Make this `Bar(69)` and it fixes it.
	}
	assert(foo.foo != nil)
}

It has to do with this hack:

Odin/src/llvm_backend_expr.cpp

Line 4738 in 68550cf

// HACK TODO(bill): THIS IS A MASSIVE HACK!!!!

Adding a panic at types.cpp:3005 confirms the issue: GB_PANIC("type %s is not a variant of the union %s!\n", type_to_string(v), type_to_string(u));

This hack evidently does not work with nested unions.

I ran out of time to think of a fix (would probably be some kind of recursive/looping solution to account for multiple levels) so I am leaving this info here.

[xzores]

Hmm, I don't experience this, as you can see in my project it seems to work fine for the double union (the "default" struct member), but it does not work for the Maybe and then double union (The "hover" and "active" struct memebers.)

Here is the struct for clarification:

Style :: struct {
	default : Appearance,            //Works
	hover : Maybe(Appearance), //Does not work
	active : Maybe(Appearance), //Does not work
}

Appearance :: union {
	Colored_appearance,
	Patched_appearance,
	Textured_appearance,
}

[laytan]

Don't experience what? Remember a Maybe is just a union under the hood. And this also only happens with compound literals with inferred types. I am 99% sure this is your bug.