luau-bytecode 0.732.0

use luau_bytecode::builder::{BytecodeBuilder, BytecodeDumpFlags};
use luau_common::BString;
use luau_compiler::{CompileOptions, Compiler};
use luau_syntax::{
    allocator::AstArena, ast_names::AstNameTable, parser::ParseOptions, parser::parse,
};

use crate::common::compile_function0_constants;

fn compile_to_bytecode_dumps(source: &str) -> (BString, BString) {
    let arena = AstArena::new();
    let mut names = AstNameTable::new(&arena);
    let result =
        parse(source, &arena, &mut names, ParseOptions::default()).expect("source should parse");

    let mut builder = BytecodeBuilder::new();
    let mut dump_flags = BytecodeDumpFlags::default();
    dump_flags.set_code(true);
    builder.set_dump_flags(dump_flags);
    Compiler::new(CompileOptions::default())
        .compile_into(&result, &mut names, &mut builder)
        .expect("source should compile");
    (builder.dump_function(0), builder.dump_everything())
}

// Compiler.test.cpp: CompileToBytecode
#[test]
fn compile_to_bytecode() {
    let (function_dump, everything_dump) = compile_to_bytecode_dumps("return 5, 6.5");

    assert_eq!(
        function_dump,
        "\
LOADN R0 5
LOADK R1 K0 [6.5]
RETURN R0 2
"
    );

    assert_eq!(
        everything_dump,
        "\
Function 0 (??):
LOADN R0 5
LOADK R1 K0 [6.5]
RETURN R0 2

"
    );
}

// Compiler.test.cpp: DumpConstantsTables
#[test]
fn dump_constants_tables() {
    assert_eq!(
        compile_function0_constants(
            r#"
return {a=1,b=2,c=3}, {only=42}, {first=10, second=20, third=30}
"#
        ),
        "\
K0: 'a'
K1: 1
K2: 'b'
K3: 2
K4: 'c'
K5: 3
K6: {['a'] = 1 #0, ['b'] = 2 #3, ['c'] = 3 #2} sizenode=4
K7: 'only'
K8: 42
K9: {['only'] = 42 #0} sizenode=1
K10: 'first'
K11: 10
K12: 'second'
K13: 20
K14: 'third'
K15: 30
K16: {['first'] = 10 #1, ['second'] = 20 #3, ['third'] = 30 #3 (conflict)} sizenode=4
DUPTABLE R0 6
DUPTABLE R1 9
DUPTABLE R2 16
RETURN R0 3
"
    );
}