serc-cli 0.1.7

An experimental CPython bytecode compiler, written in Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use std::process::Command;

use serc::{CompileOptions, OptimizationLevel, compile_bytes_with_path_and_options};

#[test]
fn cli_uses_the_library_initial_intern_state() {
    // Shared constants containing these strings depend on whether the caller
    // imported compileall or py_compile before compiling the source.
    let source = b"\
\"\"\"module documentation\"\"\"
x = {'high', 'low', 'medium'}
def first(x):
    marker = 'ok'
    assert __debug__
    return x in {'ok', 'succeeded'}
def second(x):
    return x in {'high', 'low', 'medium'} or x in {'ok', 'succeeded'}
";
    let directory = tempfile::tempdir().unwrap();
    for extension in ["py", "pyi"] {
        let filename = format!("sharing.{extension}");
        let path = std::path::Path::new(&filename);
        fs_err::write(directory.path().join(path), source).unwrap();
        for (flag, level, suffix) in [
            (None, OptimizationLevel::Zero, ""),
            (Some("-O"), OptimizationLevel::One, ".opt-1"),
            (Some("-OO"), OptimizationLevel::Two, ".opt-2"),
            (Some("-OOO"), OptimizationLevel::Two, ".opt-3"),
        ] {
            let expected = compile_bytes_with_path_and_options(
                source,
                path,
                &CompileOptions {
                    optimization_level: level,
                    ..CompileOptions::default()
                },
            )
            .unwrap()
            .to_hash_pyc(source, true);

            let mut compiler = Command::new(env!("CARGO_BIN_EXE_serc"));
            compiler.current_dir(directory.path()).args([
                "compile",
                "--force",
                "--quiet",
                "--invalidation-mode",
                "checked-hash",
            ]);
            if let Some(flag) = flag {
                compiler.arg(flag);
            }
            let output = compiler.arg(path).output().unwrap();
            assert!(output.status.success(), "{filename} {flag:?}: {output:?}");
            let cache = directory
                .path()
                .join(format!("__pycache__/sharing.cpython-314{suffix}.pyc"));
            assert_eq!(
                fs_err::read(cache).unwrap(),
                expected,
                "{filename} {flag:?}",
            );
        }
    }
}