struct Foo[T] {
    a T
}

fn r[T]() Foo[T] {
    return Foo[T]{}
}

fn t[T](v T) !Foo[T] {
    return match typeof(v).name {
        'string' {
            r[T]()
        }
        else {
            r[T]()
        }
    }
}

fn test_main() {
    t(1)!
    t('')!
    assert true
}

type GenericMatchSumtype[T] = GenericMatchY[T] | GenericMatchZ[T]

fn (mut x GenericMatchSumtype[T]) do_it[T]() string {
    match mut x {
        GenericMatchY[T] { return 'doing GenericMatchY' }
        GenericMatchZ[T] { return 'doing GenericMatchZ' }
    }

    return ''
}

struct GenericMatchY[T] {
    name  string
    value T
}

struct GenericMatchZ[T] {
    name  string
    value T
}

fn test_match_generic_sumtype_variant_in_generic_method() {
    y := GenericMatchY[int]{
        name:  'Y'
        value: 1
    }
    z := GenericMatchZ[bool]{
        name:  'Z'
        value: true
    }

    mut x1 := GenericMatchSumtype[int](y)
    assert x1.do_it() == 'doing GenericMatchY'

    mut x2 := GenericMatchSumtype[bool](z)
    assert x2.do_it() == 'doing GenericMatchZ'
}

type MatchedGenericMethodBox[T] = MatchedGenericMethodY[T] | MatchedGenericMethodZ[T]

struct MatchedGenericMethodY[T] {
    value T
}

struct MatchedGenericMethodZ[T] {
    value T
}

fn (x MatchedGenericMethodBox[T]) explicit_variant_name[T]() string {
    match x {
        MatchedGenericMethodY[T] { return x.explicit_variant_name[T]() }
        MatchedGenericMethodZ[T] { return x.explicit_variant_name[T]() }
    }

    return ''
}

fn (y MatchedGenericMethodY[T]) explicit_variant_name[T]() string {
    return 'Y'
}

fn (z MatchedGenericMethodZ[T]) explicit_variant_name[T]() string {
    return 'Z'
}

fn (x MatchedGenericMethodBox[T]) inferred_variant_name[T]() string {
    match x {
        MatchedGenericMethodY[T] { return x.inferred_variant_name() }
        MatchedGenericMethodZ[T] { return x.inferred_variant_name() }
    }

    return ''
}

fn (x MatchedGenericMethodBox[T]) match_expr_variant_name[T]() string {
    return match x {
        MatchedGenericMethodY[T] { x.explicit_variant_name[T]() }
        MatchedGenericMethodZ[T] { x.explicit_variant_name[T]() }
    }
}

fn (y MatchedGenericMethodY[T]) inferred_variant_name[T]() string {
    return 'Y'
}

fn (z MatchedGenericMethodZ[T]) inferred_variant_name[T]() string {
    return 'Z'
}

fn test_generic_sumtype_match_calls_explicit_generic_method_on_variant() {
    y := MatchedGenericMethodBox[int](MatchedGenericMethodY[int]{
        value: 1
    })
    assert y.explicit_variant_name() == 'Y'

    z := MatchedGenericMethodBox[bool](MatchedGenericMethodZ[bool]{
        value: true
    })
    assert z.explicit_variant_name() == 'Z'
}

fn test_generic_sumtype_match_calls_explicit_generic_method_on_variant_reversed() {
    z := MatchedGenericMethodBox[bool](MatchedGenericMethodZ[bool]{
        value: true
    })
    assert z.explicit_variant_name() == 'Z'

    y := MatchedGenericMethodBox[int](MatchedGenericMethodY[int]{
        value: 1
    })
    assert y.explicit_variant_name() == 'Y'
}

fn test_generic_sumtype_match_calls_explicit_generic_method_single_instantiation() {
    y := MatchedGenericMethodBox[string](MatchedGenericMethodY[string]{
        value: 'one'
    })
    assert y.explicit_variant_name() == 'Y'

    z := MatchedGenericMethodBox[string](MatchedGenericMethodZ[string]{
        value: 'two'
    })
    assert z.explicit_variant_name() == 'Z'
}

fn test_generic_sumtype_match_calls_inferred_generic_method_on_variant() {
    z := MatchedGenericMethodBox[int](MatchedGenericMethodZ[int]{
        value: 1
    })
    assert z.inferred_variant_name() == 'Z'

    y := MatchedGenericMethodBox[bool](MatchedGenericMethodY[bool]{
        value: true
    })
    assert y.inferred_variant_name() == 'Y'
}

fn test_generic_sumtype_match_expr_calls_generic_method_on_last_variant() {
    y := MatchedGenericMethodBox[int](MatchedGenericMethodY[int]{
        value: 1
    })
    assert y.match_expr_variant_name() == 'Y'

    z := MatchedGenericMethodBox[bool](MatchedGenericMethodZ[bool]{
        value: true
    })
    assert z.match_expr_variant_name() == 'Z'
}