enhance transitive dependency features

Author: KotlinIsland

Cargo.lock

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 use std::ffi::OsStr;
 use std::fs;
 use std::io::{self, Read};
@@ -444,14 +444,22 @@ pub(crate) fn cmd_build(
     }
     let file_count = handles.len();
     let roots = module_roots(&db, &root);
+    let mut packages: BTreeSet<PathBuf> = BTreeSet::new();
     if !render_check_and_transpile(
         &db,
         &handles,
         &config,
         CheckGate::ParseErrorsOnly,
         &rebuilder,
         |bpy, src, _line_map| {
-            let py = out.join(module_relative_path(&roots, &root, bpy));
+            let relative = module_relative_path(&roots, &root, bpy);
+            if relative.components().count() > 1
+                && let Some(package) = relative.components().next()
+            {
+                packages.insert(out.join(package));
+            }
+
+            let py = out.join(relative);
             fs::create_dir_all(py.parent().unwrap())?;
             fs::write(&py, src)?;
             eprintln!("{} -> {}", bpy.display(), py.display());
@@ -461,10 +469,42 @@ pub(crate) fn cmd_build(
         return Ok(ExitStatus::Failure);
     }
 
+    write_markers(&db, &packages)?;
+
     eprintln!("\nbuild complete ({file_count} files)");
     Ok(ExitStatus::Success)
 }
 
+/// Writes the `by.typed` marker into every package the build emitted.
+///
+/// The marker is what tells a project that installs this one that its packages
+/// are basedpython's, and it carries the one thing a `pyproject.toml` cannot tell
+/// them: which of this project's dependencies are part of its own interface.
+/// Nothing installs a `pyproject.toml`, and this rides along inside the package.
+#[allow(clippy::print_stderr)]
+fn write_markers(db: &ProjectDatabase, packages: &BTreeSet<PathBuf>) -> anyhow::Result<()> {
+    let exported = db
+        .project()
+        .settings(db)
+        .analysis()
+        .exported_dependencies
+        .clone()
+        .unwrap_or_default();
+    let marker = ty_module_resolver::Marker::render(&exported);
+
+    for package in packages {
+        let path = package.join(ty_module_resolver::BY_TYPED);
+        fs::create_dir_all(package)?;
+        fs::write(&path, &marker)?;
+    }
+
+    if !exported.is_empty() {
+        eprintln!("exporting {}", exported.join(", "));
+    }
+
+    Ok(())
+}
+
 // ── compile ─────────────────────────────────────────────────────────────────
 
 /// How `by compile` was invoked.

crates/ty/docs/configuration.md

@@ -1556,6 +1556,62 @@ fn build_skips_hidden_directories() {
     );
 }
 
+/// what a project exports is not in its `pyproject.toml` as far as its users are
+/// concerned — nothing installs one — so the build writes it into the package
+#[test]
+fn build_writes_what_the_project_exports_into_its_marker() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    fs::write(
+        dir.path().join("pyproject.toml"),
+        "[project]\nname = \"my-lib\"\nversion = \"0.1.0\"\n\
+         \n[tool.basedpython.analysis]\nexported-dependencies = [\"numpy\"]\n",
+    )
+    .unwrap();
+    let package = dir.path().join("my_lib");
+    fs::create_dir_all(&package).unwrap();
+    fs::write(package.join("__init__.by"), "").unwrap();
+    fs::write(
+        package.join("frames.by"),
+        "def frame() -> int:\n    return 1\n",
+    )
+    .unwrap();
+
+    let output = Command::new(env!("CARGO_BIN_EXE_by"))
+        .arg("build")
+        .current_dir(dir.path())
+        .output()
+        .expect("failed to spawn by");
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(output.status.success(), "by build failed:\n{stderr}");
+    assert_eq!(
+        fs::read_to_string(dir.path().join("out").join("my_lib").join("by.typed")).unwrap(),
+        "exported-dependencies = [\"numpy\"]\n"
+    );
+}
+
+/// a package the build emitted is marked as basedpython's even when the project
+/// exports nothing: the file's presence is what marks it
+#[test]
+fn build_writes_a_marker_for_a_project_that_exports_nothing() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let package = dir.path().join("my_lib");
+    fs::create_dir_all(&package).unwrap();
+    fs::write(package.join("__init__.by"), "").unwrap();
+
+    let output = Command::new(env!("CARGO_BIN_EXE_by"))
+        .arg("build")
+        .current_dir(dir.path())
+        .output()
+        .expect("failed to spawn by");
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(output.status.success(), "by build failed:\n{stderr}");
+    let marker = dir.path().join("out").join("my_lib").join("by.typed");
+    assert!(marker.exists(), "expected out/my_lib/by.typed:\n{stderr}");
+    assert_eq!(fs::read_to_string(marker).unwrap(), "");
+}
+
 /// a src-layout project's `src/pkg/main.by` is the module `pkg.main`, so the
 /// emitted tree has to be rooted at `src` — mirroring the directory instead
 /// emits `out/src/pkg/main.py`, whose module is `src.pkg.main`, a name nothing

crates/ty/docs/rules.md

@@ -52,6 +52,7 @@ tracing = { workspace = true }
 ruff_python_parser = { workspace = true }
 ruff_ranged_value = { workspace = true }
 ty_project = { workspace = true, features = ["testing"] }
+ty_static = { workspace = true }
 
 camino = { workspace = true }
 insta = { workspace = true, features = ["filters"] }