Use an empty vendored file system in Ruff (#13436)

## Summary

This PR changes removes the typeshed stubs from the vendored file system
shipped with ruff
and instead ships an empty "typeshed".

Making the typeshed files optional required extracting the typshed files
into a new `ruff_vendored` crate. I do like this even if all our builds
always include typeshed because it means `red_knot_python_semantic`
contains less code that needs compiling.

This also allows us to use deflate because the compression algorithm
doesn't matter for an archive containing a single, empty file.

## Test Plan

`cargo test`

I verified with ` cargo tree -f "{p} {f}" -p <package> ` that:

* red_knot_wasm: enables `deflate` compression
* red_knot: enables `zstd` compression
* `ruff`: uses stored


I'm not quiet sure how to build the binary that maturin builds but
comparing the release artifact size with `strip = true` shows a `1.5MB`
size reduction

---------

Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>

crates/ruff_db/Cargo.toml

@@ -33,19 +33,17 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true, optional = true }
 tracing-tree = { workspace = true, optional = true }
 rustc-hash = { workspace = true }
-
-[target.'cfg(not(target_arch="wasm32"))'.dependencies]
-zip = { workspace = true, features = ["zstd"] }
+zip = { workspace = true }
 
 [target.'cfg(target_arch="wasm32")'.dependencies]
 web-time = { version = "1.1.0" }
-zip = { workspace = true, features = ["deflate"] }
 
 [dev-dependencies]
 insta = { workspace = true }
 tempfile = { workspace = true }
 
 [features]
+default = ["os"]
 cache = ["ruff_cache"]
 os = ["ignore"]
 serde = ["dep:serde", "camino/serde1"]

crates/ruff_db/src/files.rs

@@ -503,7 +503,8 @@ mod tests {
     use crate::files::{system_path_to_file, vendored_path_to_file, FileError};
     use crate::system::DbWithTestSystem;
     use crate::tests::TestDb;
-    use crate::vendored::tests::VendoredFileSystemBuilder;
+    use crate::vendored::VendoredFileSystemBuilder;
+    use zip::CompressionMethod;
 
     #[test]
     fn system_existing_file() -> crate::system::Result<()> {
@@ -548,7 +549,7 @@ mod tests {
     fn stubbed_vendored_file() -> crate::system::Result<()> {
         let mut db = TestDb::new();
 
-        let mut vendored_builder = VendoredFileSystemBuilder::new();
+        let mut vendored_builder = VendoredFileSystemBuilder::new(CompressionMethod::Stored);
         vendored_builder
             .add_file("test.pyi", "def foo() -> str")
             .unwrap();

crates/ruff_db/src/parsed.rs

@@ -79,8 +79,9 @@ mod tests {
     use crate::parsed::parsed_module;
     use crate::system::{DbWithTestSystem, SystemPath, SystemVirtualPath};
     use crate::tests::TestDb;
-    use crate::vendored::{tests::VendoredFileSystemBuilder, VendoredPath};
+    use crate::vendored::{VendoredFileSystemBuilder, VendoredPath};
     use crate::Db;
+    use zip::CompressionMethod;
 
     #[test]
     fn python_file() -> crate::system::Result<()> {
@@ -150,7 +151,7 @@ mod tests {
     fn vendored_file() {
         let mut db = TestDb::new();
 
-        let mut vendored_builder = VendoredFileSystemBuilder::new();
+        let mut vendored_builder = VendoredFileSystemBuilder::new(CompressionMethod::Stored);
         vendored_builder
             .add_file(
                 "path.pyi",

crates/ruff_db/src/vendored.rs

@@ -1,12 +1,13 @@
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::fmt::{self, Debug};
-use std::io::{self, Read};
+use std::io::{self, Read, Write};
 use std::sync::{Arc, Mutex, MutexGuard};
 
-use zip::{read::ZipFile, ZipArchive, ZipWriter};
-
 use crate::file_revision::FileRevision;
+use zip::result::ZipResult;
+use zip::write::FileOptions;
+use zip::{read::ZipFile, CompressionMethod, ZipArchive, ZipWriter};
 
 pub use self::path::{VendoredPath, VendoredPathBuf};
 
@@ -177,7 +178,6 @@ struct ZipFileDebugInfo {
     crc32_hash: u32,
     compressed_size: u64,
     uncompressed_size: u64,
-    compression_method: zip::CompressionMethod,
     kind: FileType,
 }
 
@@ -187,7 +187,6 @@ impl<'a> From<ZipFile<'a>> for ZipFileDebugInfo {
             crc32_hash: value.crc32(),
             compressed_size: value.compressed_size(),
             uncompressed_size: value.size(),
-            compression_method: value.compression(),
             kind: if value.is_dir() {
                 FileType::Directory
             } else {
@@ -341,69 +340,61 @@ impl<'a> From<&'a VendoredPath> for NormalizedVendoredPath<'a> {
     }
 }
 
+pub struct VendoredFileSystemBuilder {
+    writer: ZipWriter<io::Cursor<Vec<u8>>>,
+    compression_method: CompressionMethod,
+}
+
+impl VendoredFileSystemBuilder {
+    pub fn new(compression_method: CompressionMethod) -> Self {
+        let buffer = io::Cursor::new(Vec::new());
+
+        Self {
+            writer: ZipWriter::new(buffer),
+            compression_method,
+        }
+    }
+
+    pub fn add_file(
+        &mut self,
+        path: impl AsRef<VendoredPath>,
+        content: &str,
+    ) -> std::io::Result<()> {
+        self.writer
+            .start_file(path.as_ref().as_str(), self.options())?;
+        self.writer.write_all(content.as_bytes())
+    }
+
+    pub fn add_directory(&mut self, path: impl AsRef<VendoredPath>) -> ZipResult<()> {
+        self.writer
+            .add_directory(path.as_ref().as_str(), self.options())
+    }
+
+    pub fn finish(mut self) -> Result<VendoredFileSystem> {
+        let buffer = self.writer.finish()?;
+
+        VendoredFileSystem::new(buffer.into_inner())
+    }
+
+    fn options(&self) -> FileOptions {
+        FileOptions::default()
+            .compression_method(self.compression_method)
+            .unix_permissions(0o644)
+    }
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
-    use std::io::Write;
 
     use insta::assert_snapshot;
-    use zip::result::ZipResult;
-    use zip::write::FileOptions;
-    use zip::{CompressionMethod, ZipWriter};
 
     use super::*;
 
     const FUNCTOOLS_CONTENTS: &str = "def update_wrapper(): ...";
     const ASYNCIO_TASKS_CONTENTS: &str = "class Task: ...";
 
-    pub struct VendoredFileSystemBuilder {
-        writer: ZipWriter<io::Cursor<Vec<u8>>>,
-    }
-
-    impl Default for VendoredFileSystemBuilder {
-        fn default() -> Self {
-            Self::new()
-        }
-    }
-
-    impl VendoredFileSystemBuilder {
-        pub fn new() -> Self {
-            let buffer = io::Cursor::new(Vec::new());
-
-            Self {
-                writer: ZipWriter::new(buffer),
-            }
-        }
-
-        pub fn add_file(
-            &mut self,
-            path: impl AsRef<VendoredPath>,
-            content: &str,
-        ) -> std::io::Result<()> {
-            self.writer
-                .start_file(path.as_ref().as_str(), Self::options())?;
-            self.writer.write_all(content.as_bytes())
-        }
-
-        pub fn add_directory(&mut self, path: impl AsRef<VendoredPath>) -> ZipResult<()> {
-            self.writer
-                .add_directory(path.as_ref().as_str(), Self::options())
-        }
-
-        pub fn finish(mut self) -> Result<VendoredFileSystem> {
-            let buffer = self.writer.finish()?;
-
-            VendoredFileSystem::new(buffer.into_inner())
-        }
-
-        fn options() -> FileOptions {
-            FileOptions::default()
-                .compression_method(CompressionMethod::Zstd)
-                .unix_permissions(0o644)
-        }
-    }
-
     fn mock_typeshed() -> VendoredFileSystem {
-        let mut builder = VendoredFileSystemBuilder::new();
+        let mut builder = VendoredFileSystemBuilder::new(CompressionMethod::Stored);
 
         builder.add_directory("stdlib/").unwrap();
         builder
@@ -441,28 +432,24 @@ pub(crate) mod tests {
                     crc32_hash: 0,
                     compressed_size: 0,
                     uncompressed_size: 0,
-                    compression_method: Stored,
                     kind: Directory,
                 },
                 "stdlib/asyncio/": ZipFileDebugInfo {
                     crc32_hash: 0,
                     compressed_size: 0,
                     uncompressed_size: 0,
-                    compression_method: Stored,
                     kind: Directory,
                 },
                 "stdlib/asyncio/tasks.pyi": ZipFileDebugInfo {
                     crc32_hash: 2826547428,
-                    compressed_size: 24,
+                    compressed_size: 15,
                     uncompressed_size: 15,
-                    compression_method: Zstd,
                     kind: File,
                 },
                 "stdlib/functools.pyi": ZipFileDebugInfo {
                     crc32_hash: 1099005079,
-                    compressed_size: 34,
+                    compressed_size: 25,
                     uncompressed_size: 25,
-                    compression_method: Zstd,
                     kind: File,
                 },
             },