mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-22 08:30:11 +01:00
1808df02c0
Closes https://github.com/zed-industries/zed/issues/22408 See also https://github.com/zed-industries/scap/commit/b5c86ec58dd4b6b7732bf6ac8be03d6b1f190a82 that makes all macOS dependencies optional: we do not use these in Zed anyway, and have `default-features = false` that allow to remove all transitive `block` dependencies from the tree. Adjust the test to ensure no such dependencies can appear later. Release Notes: - [GPUI] Removed `block` dependecy from the tree
368 lines
14 KiB
Rust
368 lines
14 KiB
Rust
use anyhow::{Context as _, Result};
|
|
use cargo_metadata::{Metadata, MetadataCommand};
|
|
|
|
/// Returns the Cargo workspace.
|
|
pub fn load_workspace() -> Result<Metadata> {
|
|
MetadataCommand::new()
|
|
.exec()
|
|
.context("failed to load cargo metadata")
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::{
|
|
collections::{BTreeMap, BTreeSet, VecDeque},
|
|
fs,
|
|
};
|
|
|
|
use anyhow::{Context as _, Result};
|
|
use cargo_metadata::{CargoOpt, DependencyKind, Metadata, MetadataCommand};
|
|
|
|
use super::load_workspace;
|
|
|
|
const FORBIDDEN_OBJC_DEPENDENCIES: &[(&str, &str)] = &[
|
|
("block", "use `block2` instead"),
|
|
(
|
|
"cocoa",
|
|
"use `objc2-app-kit` and `objc2-foundation` instead",
|
|
),
|
|
("cocoa-foundation", "use `objc2-foundation` instead"),
|
|
("metal", "use `objc2-metal` and `objc2-quartz-core` instead"),
|
|
("objc", "use `objc2` instead"),
|
|
("objc-foundation", "use `objc2-foundation` instead"),
|
|
("objc_id", "use `objc2::rc::Retained` instead"),
|
|
];
|
|
|
|
/// Crates that must not depend on each other, directly or transitively:
|
|
/// such edges chain large UI crates one after another and serialize the
|
|
/// build, badly hurting incremental compile times. Dev-dependencies are
|
|
/// exempt since they don't affect `cargo build`.
|
|
const FORBIDDEN_DEPENDENCIES: &[(&str, &str)] = &[
|
|
("agent_ui", "git_ui"),
|
|
("file_finder", "project_panel"),
|
|
("git_ui", "agent_ui"),
|
|
("git_ui", "search"),
|
|
("open_path_prompt", "project_panel"),
|
|
("picker", "editor"),
|
|
("project_panel", "git_ui"),
|
|
("project_panel", "search"),
|
|
("search", "git_ui"),
|
|
("search", "project_panel"),
|
|
("sidebar", "git_ui"),
|
|
("title_bar", "git_ui"),
|
|
];
|
|
|
|
#[test]
|
|
fn no_forbidden_objc_dependencies() -> Result<()> {
|
|
let workspace = MetadataCommand::new()
|
|
.features(CargoOpt::AllFeatures)
|
|
.exec()
|
|
.context("loading cargo metadata with all workspace features")?;
|
|
let violations = forbidden_objc_dependency_violations(&workspace)?;
|
|
|
|
assert_eq!(
|
|
violations,
|
|
Vec::<String>::new(),
|
|
"forbidden Objective-C dependencies:\n{}",
|
|
violations.join("\n"),
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn forbidden_objc_dependencies_cover_manifests_and_transitive_packages() -> Result<()> {
|
|
let fixture = tempfile::tempdir()?;
|
|
for name in [
|
|
"block",
|
|
"cocoa",
|
|
"cocoa-foundation",
|
|
"objc",
|
|
"objc-foundation",
|
|
"objc_id",
|
|
"block2",
|
|
"objc2",
|
|
"objc2-app-kit",
|
|
"objc2-foundation",
|
|
"objc2-metal",
|
|
"objc2-quartz-core",
|
|
"metal",
|
|
"intermediate",
|
|
"workspace",
|
|
] {
|
|
let directory = fixture.path().join(name);
|
|
fs::create_dir(&directory)?;
|
|
fs::write(directory.join("lib.rs"), "")?;
|
|
let dependencies = match name {
|
|
"metal" => "[dependencies]\nobjc = { path = '../objc' }\n",
|
|
"intermediate" => {
|
|
"[dependencies]\nmetal = { path = '../metal', optional = true }\n"
|
|
}
|
|
_ => "",
|
|
};
|
|
fs::write(
|
|
directory.join("Cargo.toml"),
|
|
format!(
|
|
"[package]\nname = '{name}'\nversion = '0.1.0'\nedition = '2024'\n\
|
|
[lib]\npath = 'lib.rs'\n{dependencies}"
|
|
),
|
|
)?;
|
|
}
|
|
let manifest = fixture.path().join("workspace/Cargo.toml");
|
|
let allowed = format!(
|
|
"{}\n{}",
|
|
fs::read_to_string(&manifest)?,
|
|
r#"[workspace]
|
|
resolver = "2"
|
|
[dependencies]
|
|
block2 = { path = "../block2" }
|
|
objc2 = { path = "../objc2" }
|
|
objc2-app-kit = { path = "../objc2-app-kit" }
|
|
objc2-foundation = { path = "../objc2-foundation" }
|
|
objc2-metal = { path = "../objc2-metal" }
|
|
objc2-quartz-core = { path = "../objc2-quartz-core" }
|
|
"#,
|
|
);
|
|
let forbidden = r#"
|
|
[dependencies.block]
|
|
path = "../block"
|
|
[dependencies.legacy_cocoa]
|
|
package = "cocoa"
|
|
path = "../cocoa"
|
|
[dependencies.cocoa-foundation]
|
|
path = "../cocoa-foundation"
|
|
optional = true
|
|
[dependencies.legacy_metal]
|
|
package = "metal"
|
|
path = "../metal"
|
|
[target.'cfg(any())'.dependencies]
|
|
objc = { path = "../objc" }
|
|
[dev-dependencies]
|
|
objc-foundation = { path = "../objc-foundation" }
|
|
[target.'cfg(any())'.build-dependencies]
|
|
legacy_id = { workspace = true, optional = true }
|
|
[workspace.dependencies]
|
|
legacy_id = { package = "objc_id", path = "../objc_id" }
|
|
objc = "0.1.0"
|
|
unused_cocoa = { package = "cocoa", version = "0.1.0" }
|
|
unused_metal = { package = "metal", version = "0.1.0" }
|
|
unused_objc2 = { package = "objc2", version = "0.1.0" }
|
|
"#;
|
|
fs::write(&manifest, format!("{allowed}{forbidden}"))?;
|
|
let mut command = MetadataCommand::new();
|
|
command
|
|
.manifest_path(&manifest)
|
|
.other_options(vec!["--offline".to_owned()]);
|
|
let mut violations = forbidden_objc_dependency_violations(&command.exec()?)?;
|
|
violations.sort();
|
|
assert_eq!(
|
|
violations,
|
|
[
|
|
"Cargo.toml [workspace.dependencies]: `legacy_id` uses `objc_id`; use `objc2::rc::Retained` instead",
|
|
"Cargo.toml [workspace.dependencies]: `objc` uses `objc`; use `objc2` instead",
|
|
"Cargo.toml [workspace.dependencies]: `unused_cocoa` uses `cocoa`; use `objc2-app-kit` and `objc2-foundation` instead",
|
|
"Cargo.toml [workspace.dependencies]: `unused_metal` uses `metal`; use `objc2-metal` and `objc2-quartz-core` instead",
|
|
"workspace directly depends on `block`; use `block2` instead",
|
|
"workspace directly depends on `cocoa-foundation`; use `objc2-foundation` instead",
|
|
"workspace directly depends on `cocoa`; use `objc2-app-kit` and `objc2-foundation` instead",
|
|
"workspace directly depends on `metal`; use `objc2-metal` and `objc2-quartz-core` instead",
|
|
"workspace directly depends on `objc-foundation`; use `objc2-foundation` instead",
|
|
"workspace directly depends on `objc_id`; use `objc2::rc::Retained` instead",
|
|
"workspace directly depends on `objc`; use `objc2` instead",
|
|
],
|
|
"including renamed optional inactive-target build dependency",
|
|
);
|
|
fs::write(
|
|
&manifest,
|
|
format!(
|
|
"{allowed}\n[target.'cfg(any())'.dependencies]\n\
|
|
intermediate = {{ path = '../intermediate', optional = true }}\n\
|
|
[features]\nlegacy = ['dep:intermediate', 'intermediate/metal']\n"
|
|
),
|
|
)?;
|
|
assert_eq!(
|
|
forbidden_objc_dependency_violations(&command.exec()?)?,
|
|
Vec::<String>::new(),
|
|
);
|
|
command.features(CargoOpt::AllFeatures);
|
|
let mut violations = forbidden_objc_dependency_violations(&command.exec()?)?;
|
|
violations.sort();
|
|
assert_eq!(
|
|
violations,
|
|
[
|
|
"dependency graph contains `metal`; use `objc2-metal` and `objc2-quartz-core` instead",
|
|
"dependency graph contains `objc`; use `objc2` instead",
|
|
],
|
|
);
|
|
fs::write(&manifest, allowed)?;
|
|
assert_eq!(
|
|
forbidden_objc_dependency_violations(&command.exec()?)?,
|
|
Vec::<String>::new(),
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn no_test_support_in_non_dev_dependencies() {
|
|
let workspace = load_workspace().expect("failed to load cargo metadata");
|
|
let mut violations = Vec::new();
|
|
|
|
for package in workspace.workspace_packages() {
|
|
for dependency in &package.dependencies {
|
|
if dependency.kind == DependencyKind::Development
|
|
|| !dependency
|
|
.features
|
|
.iter()
|
|
.any(|feature| feature == "test-support")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
let manifest = package
|
|
.manifest_path
|
|
.strip_prefix(&workspace.workspace_root)
|
|
.unwrap_or(&package.manifest_path);
|
|
let name = dependency.rename.as_deref().unwrap_or(&dependency.name);
|
|
let target = dependency
|
|
.target
|
|
.as_ref()
|
|
.map(|target| format!(" for {target}"))
|
|
.unwrap_or_default();
|
|
violations.push(format!(
|
|
"{manifest}: `{name}` enables `test-support` in {:?} dependencies{target}",
|
|
dependency.kind,
|
|
));
|
|
}
|
|
}
|
|
|
|
assert!(
|
|
violations.is_empty(),
|
|
"non-dev dependencies must not enable `test-support`; \
|
|
use dev-dependencies or explicit feature forwarding instead:\n{violations:?}",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_forbidden_dependencies_between_feature_crates() {
|
|
let workspace = load_workspace().expect("failed to load cargo metadata");
|
|
let packages = workspace.workspace_packages();
|
|
let member_names = packages
|
|
.iter()
|
|
.map(|package| package.name.as_str())
|
|
.collect::<BTreeSet<_>>();
|
|
|
|
let mut graph = BTreeMap::new();
|
|
for package in &packages {
|
|
let dependencies = package
|
|
.dependencies
|
|
.iter()
|
|
.filter(|dependency| dependency.kind != DependencyKind::Development)
|
|
.map(|dependency| dependency.name.as_str())
|
|
.filter(|name| member_names.contains(name))
|
|
.collect::<BTreeSet<_>>();
|
|
graph.insert(package.name.as_str(), dependencies);
|
|
}
|
|
|
|
let mut violations = Vec::new();
|
|
for &(from, to) in FORBIDDEN_DEPENDENCIES {
|
|
if let Some(path) = dependency_path(&graph, from, to) {
|
|
violations.push(path.join(" -> "));
|
|
}
|
|
}
|
|
assert_eq!(
|
|
violations,
|
|
Vec::<String>::new(),
|
|
"forbidden dependency paths between sibling feature crates; \
|
|
break the dependency (e.g. by extracting shared code into a lower-level crate) \
|
|
instead of joining these crates into one serial build chain",
|
|
);
|
|
}
|
|
|
|
fn forbidden_objc_dependency_violations(workspace: &Metadata) -> Result<Vec<String>> {
|
|
let mut violations = Vec::new();
|
|
let mut reported_dependencies = BTreeSet::new();
|
|
for package in workspace.workspace_packages() {
|
|
for dependency in &package.dependencies {
|
|
let Some((_, reason)) = FORBIDDEN_OBJC_DEPENDENCIES
|
|
.iter()
|
|
.find(|(name, _)| *name == dependency.name)
|
|
else {
|
|
continue;
|
|
};
|
|
violations.push(format!(
|
|
"{} directly depends on `{}`; {reason}",
|
|
package.name, dependency.name
|
|
));
|
|
reported_dependencies.insert(dependency.name.as_str());
|
|
}
|
|
}
|
|
for package in &workspace.packages {
|
|
let Some((_, reason)) = FORBIDDEN_OBJC_DEPENDENCIES
|
|
.iter()
|
|
.find(|(name, _)| *name == package.name.as_str())
|
|
else {
|
|
continue;
|
|
};
|
|
if reported_dependencies.insert(package.name.as_str()) {
|
|
violations.push(format!(
|
|
"dependency graph contains `{}`; {reason}",
|
|
package.name,
|
|
));
|
|
}
|
|
}
|
|
|
|
let manifest_path = workspace.workspace_root.join("Cargo.toml");
|
|
let contents = fs::read_to_string(&manifest_path)
|
|
.with_context(|| format!("failed to read {manifest_path}"))?;
|
|
let manifest = toml::from_str::<toml::Value>(&contents)
|
|
.with_context(|| format!("failed to parse {manifest_path}"))?;
|
|
let dependencies = manifest
|
|
.get("workspace")
|
|
.and_then(|workspace| workspace.get("dependencies"))
|
|
.and_then(toml::Value::as_table);
|
|
for (alias, dependency) in dependencies.into_iter().flatten() {
|
|
let name = dependency
|
|
.get("package")
|
|
.and_then(toml::Value::as_str)
|
|
.unwrap_or(alias);
|
|
let Some((_, reason)) = FORBIDDEN_OBJC_DEPENDENCIES
|
|
.iter()
|
|
.find(|(forbidden, _)| *forbidden == name)
|
|
else {
|
|
continue;
|
|
};
|
|
violations.push(format!(
|
|
"Cargo.toml [workspace.dependencies]: `{alias}` uses `{name}`; {reason}"
|
|
));
|
|
}
|
|
Ok(violations)
|
|
}
|
|
|
|
fn dependency_path<'a>(
|
|
graph: &BTreeMap<&'a str, BTreeSet<&'a str>>,
|
|
from: &'a str,
|
|
to: &str,
|
|
) -> Option<Vec<&'a str>> {
|
|
let mut parents = BTreeMap::new();
|
|
let mut queue = VecDeque::from([from]);
|
|
while let Some(current) = queue.pop_front() {
|
|
if current == to {
|
|
let mut path = vec![current];
|
|
let mut node = current;
|
|
while let Some(&parent) = parents.get(node) {
|
|
path.push(parent);
|
|
node = parent;
|
|
}
|
|
path.reverse();
|
|
return Some(path);
|
|
}
|
|
for &dependency in graph.get(current).into_iter().flatten() {
|
|
if dependency != from && !parents.contains_key(dependency) {
|
|
parents.insert(dependency, current);
|
|
queue.push_back(dependency);
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
}
|