lux-lib 0.70.1

Library for the lux package manager for Lua
Documentation 
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::{
    collections::HashMap,
    path::{Path, PathBuf},
};

use miette::Diagnostic;
use target_lexicon::Triple;
use thiserror::Error;

use crate::{
    build::external_dependency::ExternalDependencyInfo, config::Config, fs,
    lua_installation::LuaInstallation, lua_rockspec::LuaModule,
};

use super::{c_link, CCExt};

#[derive(Error, Debug, Diagnostic)]
#[non_exhaustive]
pub enum Error {
    #[error(transparent)]
    #[diagnostic(transparent)]
    Fs(#[from] fs::Error),
    #[error("failed to compile intermediates from C files")]
    #[diagnostic(help(
        r#"check the compiler output above for missing headers or syntax errors.
ensure the C compiler has access to the required include paths."#
    ))]
    CompileIntermediates { source: cc::Error },
    #[error("error compiling C files (compilation failed):")]
    #[diagnostic(help(
        r#"check the compiler output above for details.
if no C compiler was found, run `lx debug toolchains` to verify your build tools."#
    ))]
    Compilation(#[from] cc::Error),
    #[error("error compiling C files (linking failed)")]
    #[diagnostic(forward(0))]
    Link(#[from] c_link::Error),
}

/// Compiles a set of C files into a single dynamic library and places them under `{target_dir}/{target_file}`.
/// # Panics
/// Panics if no parent or no filename can be determined for the target path.
#[tracing::instrument(
    name = "Compiling C files",
    level = "info",
    skip_all,
    fields(profile = config.build_profile().to_string()),
)]
pub(crate) async fn compile(
    files: &Vec<PathBuf>,
    target_module: &LuaModule,
    target_dir: &Path,
    lua: &LuaInstallation,
    external_dependencies: &HashMap<String, ExternalDependencyInfo>,
    config: &Config,
) -> Result<(), Error> {
    let target = target_dir.join(target_module.to_lib_path());
    let target_parent_dir = target.parent().unwrap_or_else(|| {
        unreachable!(
            "couldn't determine build target parent directory:\n{}",
            target.display()
        )
    });
    let target_file_name = target
        .file_name()
        .unwrap_or_default()
        .to_string_lossy()
        .to_string();

    fs::sync::create_dir_all(target_parent_dir)?;

    let host = Triple::host();

    // See https://github.com/rust-lang/cc-rs/issues/594#issuecomment-2110551057

    let mut build = cc::Build::new();
    let intermediate_dir = fs::tempfile::tempdir()?;
    let build = build
        .cargo_output(config.verbose())
        .cargo_debug(config.verbose())
        .cargo_metadata(config.verbose())
        .cargo_warnings(config.verbose())
        .warnings(config.verbose())
        .files(files)
        .host(&host.to_string())
        .target(&host.to_string())
        .includes(lua.includes())
        .includes(
            external_dependencies
                .values()
                .filter_map(|dep| dep.include_dir.as_ref()),
        )
        .opt_level(config.build_profile().opt_level())
        .out_dir(intermediate_dir);

    let compiler = build.try_get_compiler()?;
    // Suppress all warnings
    if compiler.is_like_msvc() {
        build.flag("-W0");
    } else {
        build.flag("-w");
    }
    for arg in lua.define_flags() {
        build.flag(&arg);
    }

    let objects = build
        .try_compile_objects(config)
        .map_err(|source| Error::CompileIntermediates { source })?;

    c_link::artifacts(
        build,
        lua,
        external_dependencies,
        &target_file_name,
        Vec::new(),
        Vec::new(),
        target_module,
        target_parent_dir,
        objects,
        config,
    )
    .await?;
    Ok(())
}