type Node = Expr | string
type Expr = IfExpr | IntegerLiteral

struct IntegerLiteral {}

struct IfExpr {
	pos int
}

struct NodeWrapper {
	node Node
}

fn test_nested_sumtype_match_selector() {
	c := NodeWrapper{Node(Expr(IfExpr{
		pos: 1
	}))}
	match c.node {
		Expr {
			match c.node {
				IfExpr {
					assert c.node.pos == 1
				}
				else {
					assert false
				}
			}
		}
		else {
			assert false
		}
	}
}

fn test_nested_sumtype_match() {
	c := Node(Expr(IfExpr{
		pos: 1
	}))
	match c {
		Expr {
			match c {
				IfExpr {
					assert c.pos == 1
				}
				else {
					assert false
				}
			}
		}
		else {
			assert false
		}
	}
}

struct Milk {
mut:
	name string
}

struct Eggs {
mut:
	name string
}

type Food = Eggs | Milk

struct FoodWrapper {
mut:
	food Food
}

fn test_match_mut() {
	mut f := Food(Milk{'test'})
	match mut f {
		Eggs {
			f.name = 'eggs'
			assert f.name == 'eggs'
		}
		Milk {
			f.name = 'milk'
			assert f.name == 'milk'
		}
	}
}

fn test_match_mut_selector() {
	mut f := FoodWrapper{Food(Milk{'test'})}
	match mut f.food {
		Eggs {
			f.food.name = 'eggs'
			assert f.food.name == 'eggs'
		}
		Milk {
			f.food.name = 'milk'
			assert f.food.name == 'milk'
		}
	}
}

// for issue 20167
type Any_1 = f64 | int | string
type Any_2 = int | string

struct Struct {
	field Any_2
}

fn test_branches_return_struct_field() {
	any_2 := Struct{Any_2(42)}
	m := {
		'item1': Any_1('')
		'item2': match any_2.field {
			string { any_2.field }
			int { any_2.field }
		}
	}
	assert m['item2']! == Any_1(42)
}

struct NestedMatchA {
	a int
}

struct NestedMatchB {
	b int
}

struct NestedMatchC {
	c int
}

type NestedMatchD = NestedMatchA | NestedMatchB
type NestedMatchE = NestedMatchC | NestedMatchD

fn describe_nested_match(e NestedMatchE) string {
	return match e {
		NestedMatchA { 'A:${e.a}' }
		NestedMatchB { 'B:${e.b}' }
		NestedMatchC { 'C:${e.c}' }
	}
}

fn pass_nested_match(e NestedMatchE) NestedMatchE {
	return e
}

fn test_nested_sumtype_leaf_match_and_argument() {
	a := NestedMatchA{
		a: 1
	}
	b := NestedMatchB{
		b: 2
	}
	c := NestedMatchC{
		c: 3
	}

	assert describe_nested_match(a) == 'A:1'
	assert describe_nested_match(b) == 'B:2'
	assert describe_nested_match(c) == 'C:3'
	assert describe_nested_match(pass_nested_match(a)) == 'A:1'
}