const version = 123
const disable_opt_features = true

// Note: the `unknown_fn()` calls are here on purpose, to make sure that anything
// that doesn't match a compile-time condition is not even parsed.
fn test_ct_expressions() {
    mut result := ''
    foo := version
    bar := foo
    $if bar == 123 {
        result += 'a'
        assert true
    } $else {
        unknown_fn()
    }

    $if bar != 123 {
        unknown_fn()
    } $else $if bar != 124 {
        result += 'b'
        assert true
    } $else {
        unknown_fn()
    }

    $if !disable_opt_features {
        unknown_fn()
    } $else {
        result += 'c'
        assert true
    }
    assert result == 'abc'
}

fn generic_t_is[O]() O {
    $if O is string {
        return "It's a string!"
    } $else {
        return O{}
    }
    return O{}
}

struct GenericTIsTest {}

fn test_generic_t_is() {
    assert generic_t_is[string]() == "It's a string!"
    assert generic_t_is[GenericTIsTest]() == GenericTIsTest{}
}

fn generic_t_is2[T]() ?T {
    $if T is string {
        return "It's a string!"
    } $else {
        return T{}
    }
}

fn test_generic_t_is2() {
    res := generic_t_is2[string]() or {
        assert false
        ''
    }
    res2 := generic_t_is2[GenericTIsTest]() or {
        assert false
        GenericTIsTest{}
    }
    assert res == "It's a string!"
    assert res2 == GenericTIsTest{}
}

fn generic_t_is3[T](raw_data string) ?T {
    $if T is string {
        return ''
    }
    return T{}
}

fn test_generic_t_is3() {
    res := generic_t_is3[GenericTIsTest]('') or {
        assert false
        GenericTIsTest{}
    }
    assert res == GenericTIsTest{}
}

fn generic_t_is_with_else[T](raw_data string) ?T {
    $if T is string {
        return raw_data
    } $else {
        return T{}
    }
}

fn test_generic_t_is_with_else() {
    res := generic_t_is_with_else[GenericTIsTest]('') or {
        assert false
        GenericTIsTest{}
    }
    assert res == GenericTIsTest{}
    str := generic_t_is_with_else[string]('test') or {
        assert false
        ''
    }
    assert str == 'test'
}

fn generic_t_is_with_else_if[T]() []string {
    mut fields := []string{}
    $for field in T.fields {
        $if field.typ is string {
            fields << field.name
        } $else $if field.typ is int {
            fields << field.name
        }
    }
    return fields
}

struct User {
    name string
    age  int
}

fn test_generic_t_is_with_else_if() {
    x := generic_t_is_with_else_if[User]()
    assert x == ['name', 'age']
}