Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

18.4 KB
Raw Blame
//! CMake targets come from the File API codemodel, including evaluated subdirectories.

use super::{ConfigExt, config};
use crate::{BeforeLaunchTask, RunConfig};
use ide_core::settings::CMakeProfile;
use serde_json::Value;
use std::fs;
use std::path::{Path, PathBuf};

fn json(path: &Path) -> Option<Value> {
    serde_json::from_slice(&fs::read(path).ok()?).ok()
}

fn reply_file(reply: &Path, name: &str) -> Option<Value> {
    // File API references are file names, never paths outside the reply directory.
    (Path::new(name).components().count() == 1).then(|| json(&reply.join(name))).flatten()
}

fn before(config: &mut RunConfig, id: &str) {
    config.extras.before_launch.push(BeforeLaunchTask { kind: "build".into(), target: id.into() });
}

#[derive(Default)]
struct Names {
    contexts: Vec<(String, String)>,
}

impl Names {
    fn push(&mut self, out: &mut Vec<RunConfig>, config: RunConfig, dir: &str, profile: &str) {
        self.contexts.push((dir.replace('\\', "/"), profile.into()));
        out.push(config);
    }

    fn apply(self, configs: &mut [RunConfig]) {
        let names: Vec<_> = configs.iter().map(|c| c.name.clone()).collect();
        for (index, config) in configs.iter_mut().enumerate() {
            let duplicates: Vec<_> = names.iter().enumerate().filter(|(_, name)| **name == names[index]).collect();
            if duplicates.len() < 2 {
                continue;
            }
            let (dir, profile) = &self.contexts[index];
            let needs_dir = duplicates.iter().any(|(other, _)| *other != index && self.contexts[*other].1 == *profile);
            let mut context = Vec::new();
            if !profile.is_empty() {
                context.push(profile.clone());
            }
            if needs_dir {
                context.push(format!("{}/", dir.trim_end_matches('/')));
            }
            if !context.is_empty() {
                config.name = format!("{} [{}]", config.name, context.join(" · "));
            }
        }
    }
}

pub(super) fn detect(root: &Path, profiles: Option<&[CMakeProfile]>, out: &mut Vec<RunConfig>) {
    let start = out.len();
    let mut names = Names::default();
    detect_configs(root, profiles, out, &mut names);
    names.apply(&mut out[start..]);
}

fn detect_configs(root: &Path, profiles: Option<&[CMakeProfile]>, out: &mut Vec<RunConfig>, names: &mut Names) {
    if !root.join("CMakeLists.txt").is_file() {
        return;
    }
    if let Some(profiles) = profiles {
        for (index, profile) in profiles.iter().enumerate() {
            detect_profile(root, profile, index, out, names);
        }
        return;
    }
    let mut builds = Vec::new();
    if let Ok(entries) = fs::read_dir(root) {
        builds.extend(entries.flatten().filter_map(|e| {
            let p = e.path();
            (p.is_dir() && p.join("CMakeCache.txt").is_file()).then_some(p)
        }));
    }
    if builds.is_empty() {
        builds.push(root.join("build"));
    }
    builds.sort();
    builds.dedup();
    for build in builds {
        let dir = build.strip_prefix(root).unwrap_or(&build).to_string_lossy().replace('\\', "/");
        let configuration = fs::read_to_string(build.join("CMakeCache.txt"))
            .ok()
            .and_then(|cache| {
                let values = cache.lines().find_map(|line| line.strip_prefix("CMAKE_CONFIGURATION_TYPES:STRING="))?;
                Some(if values.split(';').any(|c| c == "Debug") {
                    "Debug".to_owned()
                } else {
                    values.split(';').find(|s| !s.is_empty())?.to_owned()
                })
            })
            .unwrap_or_else(|| "Debug".into());
        let prefix = format!("cmake:{dir}");
        let configure_id = format!("{prefix}:configure");
        let build_id = format!("{prefix}:build");
        let mut args = vec!["-S", ".", "-B", &dir, "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"];
        if !build.join("CMakeCache.txt").is_file() {
            args.push("-DCMAKE_BUILD_TYPE=Debug");
        }
        let mut configure = config(&configure_id, "CMake Configure", "cmake", "cmake", &args);
        configure.extras.params.insert("buildDir".into(), dir.clone());
        names.push(out, configure, &dir, "");
        let mut all =
            config(&build_id, "CMake Build", "cmake", "cmake", &["--build", &dir, "--config", &configuration]);
        // `cmake --build` regenerates by itself once a build directory is configured.
        if !build.join("CMakeCache.txt").is_file() {
            before(&mut all, &configure_id);
        }
        names.push(out, all, &dir, "");
        let mut test = config(
            format!("{prefix}:test"),
            "CTest",
            "cmake",
            "ctest",
            &["--test-dir", &dir, "-C", &configuration, "--output-on-failure"],
        );
        before(&mut test, &build_id);
        names.push(out, test, &dir, "");
        targets(root, &build, &dir, &prefix, None, out, names);
    }
}

fn detect_profile(root: &Path, profile: &CMakeProfile, index: usize, out: &mut Vec<RunConfig>, names: &mut Names) {
    let dir = if profile.build_dir.trim().is_empty() {
        format!("cmake-build-{}", profile.build_type.to_lowercase())
    } else {
        profile.build_dir.clone()
    };
    let build = root.join(&dir);
    let prefix = format!("cmake:profile:{index}");
    let configure_id = format!("{prefix}:configure");
    let build_id = format!("{prefix}:build");
    let start = out.len();
    let mut configure = config(&configure_id, "CMake Configure", "cmake", "cmake", &["-S", ".", "-B", &dir]);
    if !profile.generator.trim().is_empty() {
        configure.args.extend(["-G".into(), profile.generator.clone()]);
    }
    configure.args.push(format!("-DCMAKE_BUILD_TYPE={}", profile.build_type));
    configure.args.push("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON".into());
    configure.args.extend_from_slice(&profile.cmake_args);
    configure.extras.params.insert("buildDir".into(), dir.clone());
    names.push(out, configure, &dir, &profile.name);
    let mut all =
        config(&build_id, "CMake Build", "cmake", "cmake", &["--build", &dir, "--config", &profile.build_type]);
    all.args.extend_from_slice(&profile.build_args);
    if !build.join("CMakeCache.txt").is_file() {
        before(&mut all, &configure_id);
    }
    names.push(out, all, &dir, &profile.name);
    let mut test = config(
        format!("{prefix}:test"),
        "CTest",
        "cmake",
        "ctest",
        &["--test-dir", &dir, "-C", &profile.build_type, "--output-on-failure"],
    );
    before(&mut test, &build_id);
    names.push(out, test, &dir, &profile.name);
    targets(root, &build, &dir, &prefix, Some(profile), out, names);
    for config in &mut out[start..] {
        config.env = profile.env.clone();
    }
}

fn targets(
    root: &Path,
    build: &Path,
    dir: &str,
    prefix: &str,
    profile: Option<&CMakeProfile>,
    out: &mut Vec<RunConfig>,
    names: &mut Names,
) {
    let reply = build.join(".cmake/api/v1/reply");
    let Some(index_path) = fs::read_dir(&reply).ok().and_then(|entries| {
        entries
            .flatten()
            .map(|e| e.path())
            .filter(|p| {
                let name = p.file_name().unwrap_or_default().to_string_lossy();
                name.starts_with("index-") && name.ends_with(".json")
            })
            .max()
    }) else {
        return;
    };
    let Some(index) = json(&index_path) else { return };
    let Some(reference) = index["objects"]
        .as_array()
        .and_then(|a| a.iter().find(|o| o["kind"] == "codemodel" && o["version"]["major"] == 2))
    else {
        return;
    };
    let Some(model) = reference["jsonFile"].as_str().and_then(|n| reply_file(&reply, n)) else { return };
    let Some(configurations) = model["configurations"].as_array() else { return };
    let source_root = model["paths"]["source"].as_str().map(PathBuf::from).unwrap_or_else(|| root.into());
    if source_root.canonicalize().ok() != root.canonicalize().ok() {
        return;
    }
    let source_root = dunce::canonicalize(&source_root).unwrap_or(source_root);
    for configuration in configurations {
        let name = configuration["name"].as_str().unwrap_or("");
        if profile.is_some_and(|p| !name.is_empty() && name != p.build_type) {
            continue;
        }
        let Some(targets) = configuration["targets"].as_array() else { continue };
        for target in targets {
            let Some(target) = target["jsonFile"].as_str().and_then(|n| reply_file(&reply, n)) else { continue };
            if target["type"] != "EXECUTABLE" {
                continue;
            }
            let (Some(target_name), Some(artifact)) =
                (target["name"].as_str(), target["artifacts"][0]["path"].as_str())
            else {
                continue;
            };
            let id = format!("{prefix}:{name}:{target_name}");
            let target_build_id = format!("{id}:build");
            let mut args = vec!["--build", dir, "--target", target_name];
            if !name.is_empty() {
                args.extend(["--config", name]);
            }
            let mut build_config = config(&target_build_id, format!("Build {target_name}"), "cmake", "cmake", &args);
            if let Some(profile) = profile {
                if name.is_empty() {
                    build_config.args.extend(["--config".into(), profile.build_type.clone()]);
                }
                build_config.args.extend_from_slice(&profile.build_args);
                if !build.join("CMakeCache.txt").is_file() {
                    before(&mut build_config, &format!("{prefix}:configure"));
                }
            }
            let label = profile.map_or(name, |p| p.name.as_str());
            names.push(out, build_config, dir, label);
            let binary = build.join(artifact);
            let mut run =
                config(&id, target_name, "cmake-application", &binary.to_string_lossy(), &[]).debug("lldb-dap");
            before(&mut run, &target_build_id);
            let sources: Vec<String> = target["sources"]
                .as_array()
                .into_iter()
                .flatten()
                .filter_map(|s| {
                    let p = source_root.join(s["path"].as_str()?);
                    Some(p.to_string_lossy().replace('\\', "/"))
                })
                .collect();
            run.extras.params.insert("cmakeSources".into(), sources.join("\n"));
            if let Some(recorded) = model["paths"]["source"].as_str() {
                run.extras.params.insert("cmakeSourceRoot".into(), recorded.into());
                run.extras
                    .params
                    .insert("cmakeCanonicalSourceRoot".into(), source_root.to_string_lossy().replace('\\', "/"));
            }
            names.push(out, run, dir, label);
        }
    }
}

/// Ordered configure/build commands for a CMake build configuration. Executables and CTest
/// are never executed by Build; only their explicit build prerequisites are accepted.
pub fn build_configs(configs: &[RunConfig], id: &str) -> crate::IdeResult<Vec<RunConfig>> {
    fn visit(
        configs: &[RunConfig],
        id: &str,
        chain: &mut Vec<String>,
        out: &mut Vec<RunConfig>,
    ) -> crate::IdeResult<()> {
        if chain.iter().any(|entry| entry == id) {
            return Err(ide_core::IdeError::invalid("The before launch tasks run in a cycle"));
        }
        let config = configs
            .iter()
            .find(|c| c.id == id)
            .ok_or_else(|| ide_core::IdeError::not_found(format!("Configuration '{id}' no longer exists")))?;
        if config.kind != "cmake" || !config.args.first().is_some_and(|a| a == "--build" || a == "-S") {
            return Err(ide_core::IdeError::invalid("Not a CMake configure or build configuration"));
        }
        chain.push(id.into());
        for task in &config.extras.before_launch {
            if !matches!(task.kind.as_str(), "run" | "build") || task.target.is_empty() {
                return Err(ide_core::IdeError::invalid("CMake builds require configure/build prerequisites"));
            }
            visit(configs, &task.target, chain, out)?;
        }
        chain.pop();
        if !out.iter().any(|c| c.id == id) {
            out.push(config.clone());
        }
        Ok(())
    }
    let mut out = Vec::new();
    visit(configs, id, &mut Vec::new(), &mut out)?;
    Ok(out)
}

/// Request the codemodel when executing a configure configuration.
pub fn prepare(config: &RunConfig, cwd: &Path) -> crate::IdeResult<()> {
    if config.kind == "cmake"
        && config.args.first().is_some_and(|a| a == "-S")
        && let Some(dir) = config.extras.params.get("buildDir")
    {
        let build = cwd.join(dir);
        let generator = config.args.windows(2).find(|a| a[0] == "-G").map(|a| a[1].as_str());
        if let Some(generator) = generator
            && let Ok(cache) = fs::read_to_string(build.join("CMakeCache.txt"))
            && let Some(cached) = cache.lines().find_map(|l| l.strip_prefix("CMAKE_GENERATOR:INTERNAL="))
            && cached != generator
        {
            fs::remove_file(build.join("CMakeCache.txt"))?;
            let files = build.join("CMakeFiles");
            if files.is_dir() {
                fs::remove_dir_all(files)?;
            }
        }
        let query = build.join(".cmake/api/v1/query/client-openidea");
        fs::create_dir_all(&query)?;
        fs::write(query.join("codemodel-v2"), "")?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn profiles_select_file_api_configuration_and_apply_target_options() {
        let root = tempfile::tempdir().unwrap();
        fs::write(root.path().join("CMakeLists.txt"), "project(app)").unwrap();
        let reply = root.path().join("output/.cmake/api/v1/reply");
        fs::create_dir_all(&reply).unwrap();
        let write = |name: &str, value: Value| fs::write(reply.join(name), value.to_string()).unwrap();
        write(
            "index-1.json",
            serde_json::json!({"objects":[{"kind":"codemodel","version":{"major":2},"jsonFile":"model.json"}]}),
        );
        write(
            "model.json",
            serde_json::json!({"paths":{"source":root.path()},"configurations":[
                {"name":"Debug","targets":[{"jsonFile":"debug.json"}]},
                {"name":"Release","targets":[{"jsonFile":"release.json"}]}
            ]}),
        );
        for name in ["debug", "release"] {
            write(
                &format!("{name}.json"),
                serde_json::json!({"name":"app","type":"EXECUTABLE","artifacts":[{"path":format!("{name}/app")}]}),
            );
        }
        let profile = CMakeProfile {
            name: "Production".into(),
            build_type: "Release".into(),
            build_dir: "output".into(),
            build_args: ["-j", "8", "--", "verbose=1"].map(String::from).into(),
            env: [("FOO".into(), "bar".into())].into(),
            ..Default::default()
        };
        let mut configs = Vec::new();
        detect(root.path(), Some(std::slice::from_ref(&profile)), &mut configs);
        let run = configs.iter().find(|c| c.kind == "cmake-application").unwrap();
        assert!(run.command.ends_with("release/app"));
        assert_eq!(run.env, profile.env);
        assert_eq!(configs.iter().filter(|c| c.kind == "cmake-application").count(), 1);
        let build = configs.iter().find(|c| c.id == run.extras.before_launch[0].target).unwrap();
        assert_eq!(
            build.args,
            ["--build", "output", "--target", "app", "--config", "Release", "-j", "8", "--", "verbose=1"]
        );
        assert_eq!(build.env, profile.env);
        assert_eq!(build.extras.before_launch[0].target, "cmake:profile:0:configure");
        fs::write(root.path().join("output/CMakeCache.txt"), "CMAKE_GENERATOR:INTERNAL=Ninja\n").unwrap();
        let mut configured = Vec::new();
        detect(root.path(), Some(std::slice::from_ref(&profile)), &mut configured);
        for id in ["cmake:profile:0:build", build.id.as_str()] {
            let build = configured.iter().find(|c| c.id == id).unwrap();
            assert!(build.extras.before_launch.is_empty(), "{id} should use CMake's automatic regeneration");
        }
    }

    #[test]
    fn build_dependencies_are_scoped_and_reject_cycles_or_executables() {
        let root = tempfile::tempdir().unwrap();
        let nested = root.path().join("nested");
        fs::create_dir_all(&nested).unwrap();
        fs::write(nested.join("CMakeLists.txt"), "project(app)").unwrap();
        let configs = crate::detect(root.path());
        let build = configs.iter().find(|c| c.args.first().is_some_and(|a| a == "--build")).unwrap();
        assert_eq!(build.extras.before_launch[0].kind, "build");
        let ordered = build_configs(&configs, &build.id).unwrap();
        assert_eq!(ordered.len(), 2);
        assert_eq!(ordered[0].args[0], "-S");
        assert_eq!(ordered[1].args[0], "--build");
        assert_eq!(ordered[1].cwd, build.cwd);
        assert!(build_configs(&configs, "missing").is_err());
        let mut cycle = configs.clone();
        let configure = cycle.iter_mut().find(|c| c.id == ordered[0].id).unwrap();
        before(configure, &build.id);
        assert!(build_configs(&cycle, &build.id).is_err());
        for kind in ["native", "cmake-application", "shell"] {
            let mut invalid = build.clone();
            invalid.kind = kind.into();
            assert!(build_configs(&[invalid.clone()], &invalid.id).is_err());
        }
        let test = configs.iter().find(|c| c.command == "ctest").unwrap();
        assert!(build_configs(&configs, &test.id).is_err());
    }

    #[test]
    fn generator_change_clears_only_cmake_state_at_launch() {
        let root = tempfile::tempdir().unwrap();
        let build = root.path().join("cmake-build-debug");
        fs::create_dir_all(build.join("CMakeFiles")).unwrap();
        fs::write(build.join("CMakeCache.txt"), "CMAKE_GENERATOR:INTERNAL=Unix Makefiles\n").unwrap();
        fs::write(build.join("keep.txt"), "artifact").unwrap();
        fs::write(root.path().join("CMakeLists.txt"), "project(app)").unwrap();
        let mut configs = Vec::new();
        detect(root.path(), Some(&[CMakeProfile { generator: "Ninja".into(), ..Default::default() }]), &mut configs);
        assert!(build.join("CMakeCache.txt").exists());
        prepare(&configs[0], root.path()).unwrap();
        assert!(!build.join("CMakeCache.txt").exists());
        assert!(!build.join("CMakeFiles").exists());
        assert!(build.join("keep.txt").exists());
        assert!(build.join(".cmake/api/v1/query/client-openidea/codemodel-v2").exists());
    }
}