Feature pass

.github/workflows/ci.yaml

@@ -537,6 +537,17 @@ jobs:
       # interpreters as externally managed, though this one belongs to the job alone
       - name: "Install `typing_extensions` into the interpreter"
         run: uv pip install --python "$PYTHON" --break-system-packages "typing_extensions==4.16.0"
+      # the end-to-end tests of `by run --coverage` and of a pytest run need coverage.py and
+      # pytest, and skip on an interpreter without them, as a contributor's may be. this one is
+      # given both, as the `test-python` dependency group locks them, and says so: while
+      # `BY_TEST_PYTHON_PROVIDES` names a module, a test that cannot import it fails rather
+      # than skips
+      - name: "Install pytest and coverage.py into the interpreter"
+        run: |
+          uv export --only-group test-python --no-emit-project --output-file "$RUNNER_TEMP/test-python.txt"
+          uv pip install --python "$PYTHON" --break-system-packages --require-hashes \
+            --requirements "$RUNNER_TEMP/test-python.txt"
+          echo "BY_TEST_PYTHON_PROVIDES=pytest coverage" >> "$GITHUB_ENV"
       # a separate invocation on purpose: the backend's differential tests fork processes
       # and compile C, and sharing a run with `by_transforms`' ~1800 other tests starves
       # them into failures that pass on their own

AGENTS.md

@@ -104,6 +104,10 @@ PYTHON=$(which python3.13) CARGO_PROFILE_DEV_OPT_LEVEL=1 CARGO_PROFILE_DEV_LTO=o
 
 CI pins it in a dedicated step, so it never sees this.
 
+The end-to-end tests of a `pytest` or `--coverage` run skip when `$PYTHON` cannot import `pytest` or
+`coverage`. Setting `BY_TEST_PYTHON_PROVIDES="pytest coverage"`, the modules the interpreter was
+given, makes them fail instead when it cannot import one. CI sets it.
+
 ### Fallback without nextest
 
 If `cargo nextest` is not available, use `cargo test` with the same environment variables. For the workspace, exclude `ty` and then run its other test targets explicitly. If new non-watcher test targets are added to `ty`, add them to the `ty` command below; `cargo metadata --no-deps --format-version 1` lists each crate's targets:

crates/by_stage/Cargo.toml

@@ -16,6 +16,9 @@ doctest = false
 [dependencies]
 by_transforms = { workspace = true }
 ruff_db = { workspace = true, features = ["os"] }
+ruff_python_ast = { workspace = true }
+ruff_python_parser = { workspace = true }
+ruff_text_size = { workspace = true }
 ty_module_resolver = { workspace = true }
 ty_project = { workspace = true }
 ty_python_semantic = { workspace = true }

crates/by_stage/src/lib.rs

@@ -49,6 +49,8 @@
 //!   which source, for an editor to ask.
 //! - [`run_module`] — which file `by run <module>` executes, and the module a
 //!   file runs as.
+//! - [`session`] — a `by repl` session, and whether what has been typed into it
+//!   is a whole input yet
 
 pub mod emit;
 pub mod layout;
@@ -57,6 +59,7 @@ pub mod record;
 pub mod restage;
 pub mod run_module;
 pub mod runtime;
+pub mod session;
 pub mod sourcemap;
 pub mod staging;
 pub mod verbatim;

crates/by_stage/src/project.rs

@@ -22,6 +22,8 @@ use std::path::{Path, PathBuf};
 
 use anyhow::Context;
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
+use ty_project::metadata::options::{EnvironmentOptions, Options};
+use ty_project::metadata::value::RelativePathBuf;
 use ty_project::{Db, ProjectDatabase, ProjectMetadata};
 
 /// Everything needed to build a project db a second time.
@@ -96,11 +98,50 @@ impl Rebuilder {
     }
 
     pub fn rebuild(&self) -> Box<dyn ty_python_semantic::Db> {
+        Box::new(self.project_database())
+    }
+
+    /// the same project with `extra` one of its first-party roots too, searched after its own
+    ///
+    /// a `by repl` session's module lives outside the project, and the checker reads a module
+    /// as the project's own code only from a first-party root: a `sealed` class declared in a
+    /// session can be subclassed in the session, as in any module of the project, only once the
+    /// session's module is first-party
+    #[must_use]
+    pub fn with_first_party_root(&self, extra: &SystemPath) -> Self {
+        let db = self.project_database();
+        let mut roots: Vec<RelativePathBuf> = db
+            .project()
+            .program(&db)
+            .search_paths(&db)
+            .first_party_roots()
+            .map(RelativePathBuf::cli)
+            .collect();
+        roots.push(RelativePathBuf::cli(extra));
+        let mut metadata = self.metadata.clone();
+        metadata.apply_override_options(Options {
+            environment: Some(EnvironmentOptions {
+                root: Some(roots),
+                ..EnvironmentOptions::default()
+            }),
+            ..Options::default()
+        });
+        Self {
+            metadata,
+            root: self.root.clone(),
+            included: self.included.clone(),
+        }
+    }
+
+    /// the project's db built again, and not frozen: what a caller holds that goes on
+    /// changing an input after the build, as a `by repl` session changes its module with
+    /// every input
+    pub fn project_database(&self) -> ProjectDatabase {
         let mut db =
             ProjectDatabase::use_defaults(self.metadata.clone(), OsSystem::new(&self.root));
         db.project()
             .set_included_paths(&mut db, self.included.clone());
-        Box::new(db)
+        db
     }
 }
 
@@ -267,6 +308,23 @@ pub fn build_project_db(
     cwd: &Path,
     extensions: &[&str],
     output: Option<&Path>,
+) -> anyhow::Result<ProjectBuild> {
+    build_project_db_for(cwd, extensions, output, None)
+}
+
+/// [`build_project_db`], checking the project against the python environment `python` — an
+/// interpreter or the environment holding it, as `by check --python` takes — rather than the
+/// one the project's configuration and discovery would find
+///
+/// what runs a program decides which packages it imports, so a command that runs the program on
+/// an interpreter it was told about has to check it against that interpreter's packages: checked
+/// against another environment, an import the program will find is reported as unresolved, and
+/// one it will not find passes
+pub fn build_project_db_for(
+    cwd: &Path,
+    extensions: &[&str],
+    output: Option<&Path>,
+    python: Option<&SystemPath>,
 ) -> anyhow::Result<ProjectBuild> {
     // the project root must be canonicalized the same way the included files
     // are (below) so it stays a path *prefix* of them: otherwise a file's
@@ -278,8 +336,17 @@ pub fn build_project_db(
     let sys_cwd = SystemPath::from_std_path(&canonical_cwd)
         .with_context(|| format!("non-utf8 path: {}", canonical_cwd.display()))?;
     let system = OsSystem::new(sys_cwd);
-    let project_metadata = ProjectMetadata::discover(sys_cwd, &system)
+    let mut project_metadata = ProjectMetadata::discover(sys_cwd, &system)
         .with_context(|| format!("failed to discover project at {sys_cwd}"))?;
+    if let Some(python) = python {
+        project_metadata.set_override_options(Options {
+            environment: Some(EnvironmentOptions {
+                python: Some(RelativePathBuf::cli(python)),
+                ..EnvironmentOptions::default()
+            }),
+            ..Options::default()
+        });
+    }
 
     // the project is the project wherever the command was run from. rooting this
     // at the working directory instead means `by run` inside `tests/` transpiles