//! Test conditional expression with aggregate types (tagged unions, optionals).

union Val {

    Reg(u32),

    Imm(i64),

}

fn pickVal(flag: bool, reg: u32) -> Val {

    return Val::Reg(reg) if flag else Val::Imm(99);

}

fn pickOpt(a: ?u16, b: ?u16) -> ?u16 {

    return b if a == nil else a;

}

/// Test tagged union conditional expression.

fn testUnion() -> i32 {

    let v1 = pickVal(true, 7);

    if let case Val::Reg(r) = v1 {

        if r != 7 {

            return 1;

        }

    } else {

        return 2;

    }

    let v2 = pickVal(false, 7);

    if let case Val::Imm(i) = v2 {

        if i != 99 {

            return 3;

        }

    } else {

        return 4;

    }

    return 0;

}

/// Test optional conditional expression.

fn testOptional() -> i32 {

    let a: ?u16 = 42;

    let b: ?u16 = 99;

    let n: ?u16 = nil;

    let r1 = pickOpt(a, b);

    let v1 = r1 else {

        return 10;

    };

    if v1 != 42 {

        return 11;

    }

    let r2 = pickOpt(n, b);

    let v2 = r2 else {

        return 12;

    };

    if v2 != 99 {

        return 13;

    }

    return 0;

}

@default fn main() -> i32 {

    let r1 = testUnion();

    if r1 != 0 {

        return r1;

    }

    let r2 = testOptional();

    if r2 != 0 {

        return r2;

    }

    return 0;

}

//! Test conditional expression lowering (`thenExpr if cond else elseExpr`).

fn min(a: u32, b: u32) -> u32 {

    return b if b < a else a;

}

fn pick(cond: bool, a: i32, b: i32) -> i32 {

    return a if cond else b;

}

union Color { Red, Green, Blue }

fn colorPick(isRed: bool) -> Color {

    return Color::Red if isRed else Color::Blue;

}

/// Test basic scalar conditional expression.

fn testScalar() -> i32 {

    let x: i32 = 10 if true else 20;

    if x != 10 {

        return 1;

    }

    let y: i32 = 10 if false else 20;

    if y != 20 {

        return 2;

    }

    return 0;

}

/// Test min-value pattern.

fn testMin() -> i32 {

    if min(5, 3) != 3 {

        return 10;

    }

    if min(3, 5) != 3 {

        return 11;

    }

    if min(4, 4) != 4 {

        return 12;

    }

    return 0;

}

/// Test with function argument as condition.

fn testFnArg() -> i32 {

    if pick(true, 42, 99) != 42 {

        return 20;

    }

    if pick(false, 42, 99) != 99 {

        return 21;

    }

    return 0;

}

/// Test with enum values.

fn testEnum() -> i32 {

    let c1 = colorPick(true);

    if c1 != Color::Red {

        return 30;

    }

    let c2 = colorPick(false);

    if c2 != Color::Blue {

        return 31;

    }

    return 0;

}

/// Test nested conditional expression (right-associative).

fn testNested() -> i32 {

    let a: i32 = 0;

    let b: i32 = 1;

    let c: i32 = 2;

    // a if false else b if false else c => a if false else (b if false else c) => c

    let result: i32 = a if false else b if false else c;

    if result != 2 {

        return 40;

    }

    // a if true else b if false else c => a

    let result2: i32 = a if true else b if false else c;

    if result2 != 0 {

        return 41;

    }

    return 0;

}

@default fn main() -> i32 {

    let r1 = testScalar();

    if r1 != 0 {

        return r1;

    }

    let r2 = testMin();

    if r2 != 0 {

        return r2;

    }

    let r3 = testFnArg();

    if r3 != 0 {

        return r3;

    }

    let r4 = testEnum();

    if r4 != 0 {

        return r4;

    }

    let r5 = testNested();

    if r5 != 0 {

        return r5;

    }

    return 0;

}

/// Lower a conditional expression (`thenExpr if condition else elseExpr`).

fn lowerCondExpr(self: *mut FnLowerer, node: *ast::Node, cond: ast::CondExpr) -> il::Val

    throws (LowerError)

{

    let typ = resolver::typeFor(self.low.resolver, node) else {

        throw LowerError::MissingType(node);

    };

    let thenBlock = try createBlock(self, "cond#then");

    let elseBlock = try createBlock(self, "cond#else");

    if isAggregateType(typ) {

        let dst = try emitReserve(self, typ);

        let layout = resolver::getTypeLayout(typ);

        try emitCondBranch(self, cond.condition, thenBlock, elseBlock);

        let mergeBlock = try createBlock(self, "cond#merge");

        try switchToAndSeal(self, thenBlock);

        let thenVal = try emitValToReg(self, try lowerExpr(self, cond.thenExpr));

        emit(self, il::Instr::Blit { dst, src: thenVal, size: layout.size });

        try emitJmp(self, mergeBlock);

        try switchToAndSeal(self, elseBlock);

        let elseVal = try emitValToReg(self, try lowerExpr(self, cond.elseExpr));

        emit(self, il::Instr::Blit { dst, src: elseVal, size: layout.size });

        try emitJmp(self, mergeBlock);

        try switchToAndSeal(self, mergeBlock);

        return il::Val::Reg(dst);

    } else {

        try emitCondBranch(self, cond.condition, thenBlock, elseBlock);

        let resultType = ilType(self.low, typ);

        let resultReg = nextReg(self);

        let mergeBlock = try createBlockWithParam(

            self, "cond#merge", il::Param { value: resultReg, type: resultType }

        );

        try switchToAndSeal(self, thenBlock);

        try emitJmpWithArg(self, mergeBlock, try lowerExpr(self, cond.thenExpr));

        try switchToAndSeal(self, elseBlock);

        try emitJmpWithArg(self, mergeBlock, try lowerExpr(self, cond.elseExpr));

        try switchToAndSeal(self, mergeBlock);

        return il::Val::Reg(resultReg);

    }

}

        case ast::NodeValue::CondExpr(cond) => {

            val = try lowerCondExpr(self, node, cond);

        }

//! Test lowering of conditional expressions.

fn condExpr(flag: bool) -> i32 {

    let x: i32 = 1 if flag else 2;

    return x;

}

fn w32 $condExpr(w8 %0) {

  @entry0

    br.ne w32 %0 0 @cond#then1 @cond#else2;

  @cond#then1

    jmp @cond#merge3(1);

  @cond#else2

    jmp @cond#merge3(2);

  @cond#merge3(w32 %1)

    ret %1;

}