diff --git a/Cargo.lock b/Cargo.lock index 184cb47985..6fe56896d3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -56,9 +56,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.19" +version = "0.6.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933" +checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192" dependencies = [ "anstyle", "anstyle-parse", @@ -95,18 +95,18 @@ dependencies = [ [[package]] name = "anstyle-query" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9" +checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2" dependencies = [ - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] [[package]] name = "anstyle-svg" -version = "0.1.9" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a43964079ef399480603125d5afae2b219aceffb77478956e25f17b9bc3435c" +checksum = "dc03a770ef506fe1396c0e476120ac0e6523cf14b74218dd5f18cd6833326fa9" dependencies = [ "anstyle", "anstyle-lossy", @@ -117,13 +117,13 @@ dependencies = [ [[package]] name = "anstyle-wincon" -version = "3.0.9" +version = "3.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882" +checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a" dependencies = [ "anstyle", "once_cell_polyfill", - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] [[package]] @@ -346,9 +346,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.30" +version = "1.2.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7" +checksum = "c3a42d84bb6b69d3a8b3eaacf0d88f179e1929695e1ad012b6cf64d9caaa5fd2" dependencies = [ "jobserver", "libc", @@ -408,9 +408,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.42" +version = "4.5.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed87a9d530bb41a67537289bafcac159cb3ee28460e0a4571123d2a778a6a882" +checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f" dependencies = [ "clap_builder", "clap_derive", @@ -418,9 +418,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.42" +version = "4.5.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64f4f3f3c77c94aff3c7e9aac9a2ca1974a5adf392a8bb751e827d6d127ab966" +checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65" dependencies = [ "anstream", "anstyle", @@ -492,9 +492,9 @@ dependencies = [ [[package]] name = "codspeed" -version = "3.0.4" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d29180405ab3b37bb020246ea66bf8ae233708766fd59581ae929feaef10ce91" +checksum = "35584c5fcba8059780748866387fb97c5a203bcfc563fc3d0790af406727a117" dependencies = [ "anyhow", "bincode 1.3.3", @@ -510,9 +510,9 @@ dependencies = [ [[package]] name = "codspeed-criterion-compat" -version = "3.0.4" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2454d874ca820ffd71273565530ad318f413195bbc99dce6c958ca07db362c63" +checksum = "78f6c1c6bed5fd84d319e8b0889da051daa361c79b7709c9394dfe1a882bba67" dependencies = [ "codspeed", "codspeed-criterion-compat-walltime", @@ -521,9 +521,9 @@ dependencies = [ [[package]] name = "codspeed-criterion-compat-walltime" -version = "3.0.4" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "093a9383cdd1a5a0bd1a47cdafb49ae0c6dcd0793c8fb8f79768bab423128c9c" +checksum = "c989289ce6b1cbde72ed560496cb8fbf5aa14d5ef5666f168e7f87751038352e" dependencies = [ "anes", "cast", @@ -546,9 +546,9 @@ dependencies = [ [[package]] name = "codspeed-divan-compat" -version = "3.0.4" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1c73bce1e3f47738bf74a6b58b72a49b4f40c837ce420d8d65a270298592aac" +checksum = "adf64eda57508448d59efd940bad62ede7c50b0d451a150b8d6a0eca642792a6" dependencies = [ "codspeed", "codspeed-divan-compat-macros", @@ -557,9 +557,9 @@ dependencies = [ [[package]] name = "codspeed-divan-compat-macros" -version = "3.0.4" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea51dd8add7eba774cc24b4a98324252ac3ec092ccb5f07e52bbe1cb72a6d373" +checksum = "058167258e819b16a4ba601fdfe270349ef191154758dbce122c62a698f70ba8" dependencies = [ "divan-macros", "itertools 0.14.0", @@ -571,9 +571,9 @@ dependencies = [ [[package]] name = "codspeed-divan-compat-walltime" -version = "3.0.4" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "417e9edfc4b0289d4b9b48e62f98c6168d5e30c0e612b2935e394b0dd930fe83" +checksum = "48f9866ee3a4ef9d2868823ea5811886763af244f2df584ca247f49281c43f1f" dependencies = [ "cfg-if", "clap", @@ -885,9 +885,9 @@ dependencies = [ [[package]] name = "derive-where" -version = "1.5.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "510c292c8cf384b1a340b816a9a6cf2599eb8f566a44949024af88418000c50b" +checksum = "ef941ded77d15ca19b40374869ac6000af1c9f2a4c0f3d4c70926287e6364a8f" dependencies = [ "proc-macro2", "quote", @@ -1161,9 +1161,9 @@ dependencies = [ [[package]] name = "get-size-derive2" -version = "0.6.1" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca171f9f8ed2f416ac044de2dc4acde3e356662a14ac990345639653bdc7fc28" +checksum = "75a17a226478b2e8294ded60782c03efe54476aa8cd1371d0e5ad9d1071e74e0" dependencies = [ "attribute-derive", "quote", @@ -1172,9 +1172,9 @@ dependencies = [ [[package]] name = "get-size2" -version = "0.6.1" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "965bc5c1c5fe05c5bbd398bb9b3f0f14d750261ebdd1af959f2c8a603fedb5ad" +checksum = "5697765925a05c9d401dd04a93dfd662d336cc25fdcc3301220385a1ffcfdde5" dependencies = [ "compact_str", "get-size-derive2", @@ -1805,9 +1805,9 @@ dependencies = [ [[package]] name = "libredox" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "360e552c93fa0e8152ab463bc4c4837fce76a225df11dfaeea66c313de5e61f7" +checksum = "391290121bad3d37fbddad76d8f5d1c1c314cfc646d143d7e07a3086ddff0ce3" dependencies = [ "bitflags 2.9.1", "libc", @@ -1856,9 +1856,9 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" [[package]] name = "lsp-server" -version = "0.7.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9462c4dc73e17f971ec1f171d44bfffb72e65a130117233388a0ebc7ec5656f9" +checksum = "7d6ada348dbc2703cbe7637b2dda05cff84d3da2819c24abcb305dd613e0ba2e" dependencies = [ "crossbeam-channel", "log", @@ -2671,9 +2671,9 @@ dependencies = [ [[package]] name = "redox_users" -version = "0.5.0" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" dependencies = [ "getrandom 0.2.16", "libredox", @@ -2795,7 +2795,7 @@ dependencies = [ "test-case", "thiserror 2.0.12", "tikv-jemallocator", - "toml 0.9.4", + "toml 0.9.5", "tracing", "walkdir", "wild", @@ -2811,7 +2811,7 @@ dependencies = [ "ruff_annotate_snippets", "serde", "snapbox", - "toml 0.9.4", + "toml 0.9.5", "tryfn", "unicode-width 0.2.1", ] @@ -2874,6 +2874,7 @@ dependencies = [ "ruff_annotate_snippets", "ruff_cache", "ruff_diagnostics", + "ruff_memory_usage", "ruff_notebook", "ruff_python_ast", "ruff_python_parser", @@ -2927,7 +2928,7 @@ dependencies = [ "similar", "strum", "tempfile", - "toml 0.9.4", + "toml 0.9.5", "tracing", "tracing-indicatif", "tracing-subscriber", @@ -3048,7 +3049,7 @@ dependencies = [ "tempfile", "test-case", "thiserror 2.0.12", - "toml 0.9.4", + "toml 0.9.5", "typed-arena", "unicode-normalization", "unicode-width 0.2.1", @@ -3068,6 +3069,13 @@ dependencies = [ "syn", ] +[[package]] +name = "ruff_memory_usage" +version = "0.0.0" +dependencies = [ + "get-size2", +] + [[package]] name = "ruff_notebook" version = "0.0.0" @@ -3298,7 +3306,7 @@ dependencies = [ "serde_json", "shellexpand", "thiserror 2.0.12", - "toml 0.9.4", + "toml 0.9.5", "tracing", "tracing-log", "tracing-subscriber", @@ -3388,7 +3396,7 @@ dependencies = [ "shellexpand", "strum", "tempfile", - "toml 0.9.4", + "toml 0.9.5", "unicode-normalization", ] @@ -3442,7 +3450,7 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" [[package]] name = "salsa" version = "0.23.0" -source = "git+https://github.com/salsa-rs/salsa.git?rev=d66fe331d546216132ace503512b94d5c68d2c50#d66fe331d546216132ace503512b94d5c68d2c50" +source = "git+https://github.com/salsa-rs/salsa.git?rev=b121ee46c4483ba74c19e933a3522bd548eb7343#b121ee46c4483ba74c19e933a3522bd548eb7343" dependencies = [ "boxcar", "compact_str", @@ -3466,12 +3474,12 @@ dependencies = [ [[package]] name = "salsa-macro-rules" version = "0.23.0" -source = "git+https://github.com/salsa-rs/salsa.git?rev=d66fe331d546216132ace503512b94d5c68d2c50#d66fe331d546216132ace503512b94d5c68d2c50" +source = "git+https://github.com/salsa-rs/salsa.git?rev=b121ee46c4483ba74c19e933a3522bd548eb7343#b121ee46c4483ba74c19e933a3522bd548eb7343" [[package]] name = "salsa-macros" version = "0.23.0" -source = "git+https://github.com/salsa-rs/salsa.git?rev=d66fe331d546216132ace503512b94d5c68d2c50#d66fe331d546216132ace503512b94d5c68d2c50" +source = "git+https://github.com/salsa-rs/salsa.git?rev=b121ee46c4483ba74c19e933a3522bd548eb7343#b121ee46c4483ba74c19e933a3522bd548eb7343" dependencies = [ "proc-macro2", "quote", @@ -4023,9 +4031,9 @@ dependencies = [ [[package]] name = "toml" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41ae868b5a0f67631c14589f7e250c1ea2c574ee5ba21c6c8dd4b1485705a5a1" +checksum = "75129e1dc5000bfbaa9fee9d1b21f974f9fbad9daec557a521ee6e080825f6e8" dependencies = [ "indexmap", "serde", @@ -4069,9 +4077,9 @@ dependencies = [ [[package]] name = "toml_parser" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97200572db069e74c512a14117b296ba0a80a30123fbbb5aa1f4a348f639ca30" +checksum = "b551886f449aa90d4fe2bdaa9f4a2577ad2dde302c61ecf262d80b116db95c10" dependencies = [ "winnow", ] @@ -4204,7 +4212,7 @@ dependencies = [ "ruff_python_trivia", "salsa", "tempfile", - "toml 0.9.4", + "toml 0.9.5", "tracing", "tracing-flame", "tracing-subscriber", @@ -4267,6 +4275,7 @@ dependencies = [ "ruff_cache", "ruff_db", "ruff_macros", + "ruff_memory_usage", "ruff_options_metadata", "ruff_python_ast", "ruff_python_formatter", @@ -4276,7 +4285,7 @@ dependencies = [ "schemars", "serde", "thiserror 2.0.12", - "toml 0.9.4", + "toml 0.9.5", "tracing", "ty_combine", "ty_python_semantic", @@ -4309,6 +4318,7 @@ dependencies = [ "ruff_db", "ruff_index", "ruff_macros", + "ruff_memory_usage", "ruff_python_ast", "ruff_python_literal", "ruff_python_parser", @@ -4403,7 +4413,7 @@ dependencies = [ "smallvec", "tempfile", "thiserror 2.0.12", - "toml 0.9.4", + "toml 0.9.5", "tracing", "ty_python_semantic", "ty_static", @@ -5235,9 +5245,9 @@ dependencies = [ [[package]] name = "zerovec" -version = "0.11.2" +version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" dependencies = [ "yoke", "zerofrom", diff --git a/Cargo.toml b/Cargo.toml index dcc022dfc8..ffbee4e27d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,7 @@ ruff_graph = { path = "crates/ruff_graph" } ruff_index = { path = "crates/ruff_index" } ruff_linter = { path = "crates/ruff_linter" } ruff_macros = { path = "crates/ruff_macros" } +ruff_memory_usage = { path = "crates/ruff_memory_usage" } ruff_notebook = { path = "crates/ruff_notebook" } ruff_options_metadata = { path = "crates/ruff_options_metadata" } ruff_python_ast = { path = "crates/ruff_python_ast" } @@ -84,7 +85,7 @@ etcetera = { version = "0.10.0" } fern = { version = "0.7.0" } filetime = { version = "0.2.23" } getrandom = { version = "0.3.1" } -get-size2 = { version = "0.6.0", features = [ +get-size2 = { version = "0.6.2", features = [ "derive", "smallvec", "hashbrown", @@ -142,7 +143,7 @@ regex-automata = { version = "0.4.9" } rustc-hash = { version = "2.0.0" } rustc-stable-hash = { version = "0.1.2" } # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml` -salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "d66fe331d546216132ace503512b94d5c68d2c50", default-features = false, features = [ +salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "b121ee46c4483ba74c19e933a3522bd548eb7343", default-features = false, features = [ "compact_str", "macros", "salsa_unstable", diff --git a/crates/ruff_db/Cargo.toml b/crates/ruff_db/Cargo.toml index ccc9edf480..f3df7fac70 100644 --- a/crates/ruff_db/Cargo.toml +++ b/crates/ruff_db/Cargo.toml @@ -14,6 +14,7 @@ license = { workspace = true } ruff_annotate_snippets = { workspace = true } ruff_cache = { workspace = true, optional = true } ruff_diagnostics = { workspace = true } +ruff_memory_usage = { workspace = true } ruff_notebook = { workspace = true } ruff_python_ast = { workspace = true, features = ["get-size"] } ruff_python_parser = { workspace = true } diff --git a/crates/ruff_db/src/parsed.rs b/crates/ruff_db/src/parsed.rs index 7c12cb5f90..77c71cc516 100644 --- a/crates/ruff_db/src/parsed.rs +++ b/crates/ruff_db/src/parsed.rs @@ -21,7 +21,7 @@ use crate::source::source_text; /// reflected in the changed AST offsets. /// The other reason is that Ruff's AST doesn't implement `Eq` which Salsa requires /// for determining if a query result is unchanged. -#[salsa::tracked(returns(ref), no_eq, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), no_eq, heap_size=ruff_memory_usage::heap_size)] pub fn parsed_module(db: &dyn Db, file: File) -> ParsedModule { let _span = tracing::trace_span!("parsed_module", ?file).entered(); diff --git a/crates/ruff_db/src/source.rs b/crates/ruff_db/src/source.rs index a6a7e9d635..8ebcc5568a 100644 --- a/crates/ruff_db/src/source.rs +++ b/crates/ruff_db/src/source.rs @@ -9,7 +9,7 @@ use crate::Db; use crate::files::{File, FilePath}; /// Reads the source text of a python text file (must be valid UTF8) or notebook. -#[salsa::tracked(heap_size=get_size2::heap_size)] +#[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] pub fn source_text(db: &dyn Db, file: File) -> SourceText { let path = file.path(db); let _span = tracing::trace_span!("source_text", file = %path).entered(); @@ -157,7 +157,7 @@ pub enum SourceTextError { } /// Computes the [`LineIndex`] for `file`. -#[salsa::tracked(heap_size=get_size2::heap_size)] +#[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] pub fn line_index(db: &dyn Db, file: File) -> LineIndex { let _span = tracing::trace_span!("line_index", ?file).entered(); diff --git a/crates/ruff_memory_usage/Cargo.toml b/crates/ruff_memory_usage/Cargo.toml new file mode 100644 index 0000000000..1b87de4bbf --- /dev/null +++ b/crates/ruff_memory_usage/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "ruff_memory_usage" +version = "0.0.0" +publish = false +authors = { workspace = true } +edition = { workspace = true } +rust-version = { workspace = true } +homepage = { workspace = true } +documentation = { workspace = true } +repository = { workspace = true } +license = { workspace = true } + +[dependencies] +get-size2 = { workspace = true } + +[lints] +workspace = true diff --git a/crates/ruff_memory_usage/src/lib.rs b/crates/ruff_memory_usage/src/lib.rs new file mode 100644 index 0000000000..d10c64283a --- /dev/null +++ b/crates/ruff_memory_usage/src/lib.rs @@ -0,0 +1,14 @@ +use std::sync::{LazyLock, Mutex}; + +use get_size2::{GetSize, StandardTracker}; + +/// Returns the memory usage of the provided object, using a global tracker to avoid +/// double-counting shared objects. +pub fn heap_size(value: &T) -> usize { + static TRACKER: LazyLock> = + LazyLock::new(|| Mutex::new(StandardTracker::new())); + + value + .get_heap_size_with_tracker(&mut *TRACKER.lock().unwrap()) + .0 +} diff --git a/crates/ty_project/Cargo.toml b/crates/ty_project/Cargo.toml index 77b87a18a9..29411de0d8 100644 --- a/crates/ty_project/Cargo.toml +++ b/crates/ty_project/Cargo.toml @@ -15,6 +15,7 @@ license.workspace = true ruff_cache = { workspace = true } ruff_db = { workspace = true, features = ["cache", "serde"] } ruff_macros = { workspace = true } +ruff_memory_usage = { workspace = true } ruff_options_metadata = { workspace = true } ruff_python_ast = { workspace = true, features = ["serde"] } ruff_python_formatter = { workspace = true, optional = true } diff --git a/crates/ty_project/src/db.rs b/crates/ty_project/src/db.rs index 2b995c8690..1a0e833af7 100644 --- a/crates/ty_project/src/db.rs +++ b/crates/ty_project/src/db.rs @@ -127,10 +127,9 @@ impl ProjectDatabase { /// Returns a [`SalsaMemoryDump`] that can be use to dump Salsa memory usage information /// to the CLI after a typechecker run. pub fn salsa_memory_dump(&self) -> SalsaMemoryDump { - let salsa_db = self as &dyn salsa::Database; - - let mut ingredients = salsa_db.structs_info(); - let mut memos = salsa_db.queries_info().into_iter().collect::>(); + let memory_usage = ::memory_usage(self); + let mut ingredients = memory_usage.structs; + let mut memos = memory_usage.queries.into_iter().collect::>(); ingredients.sort_by_key(|ingredient| cmp::Reverse(ingredient.size_of_fields())); memos.sort_by_key(|(_, memo)| cmp::Reverse(memo.size_of_fields())); @@ -140,12 +139,14 @@ impl ProjectDatabase { for ingredient in &ingredients { total_metadata += ingredient.size_of_metadata(); total_fields += ingredient.size_of_fields(); + total_fields += ingredient.heap_size_of_fields().unwrap_or(0); } let mut total_memo_fields = 0; let mut total_memo_metadata = 0; for (_, memo) in &memos { total_memo_fields += memo.size_of_fields(); + total_memo_fields += memo.heap_size_of_fields().unwrap_or(0); total_memo_metadata += memo.size_of_metadata(); } diff --git a/crates/ty_project/src/lib.rs b/crates/ty_project/src/lib.rs index 2ea0df54a0..dcf1d2f0ae 100644 --- a/crates/ty_project/src/lib.rs +++ b/crates/ty_project/src/lib.rs @@ -201,7 +201,7 @@ impl Project { /// This is a salsa query to prevent re-computing queries if other, unrelated /// settings change. For example, we don't want that changing the terminal settings /// invalidates any type checking queries. - #[salsa::tracked(returns(deref), heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(deref), heap_size=ruff_memory_usage::heap_size)] pub fn rules(self, db: &dyn Db) -> Arc { self.settings(db).to_rules() } @@ -524,7 +524,7 @@ impl Project { } } -#[salsa::tracked(returns(ref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), heap_size=ruff_memory_usage::heap_size)] pub(crate) fn check_file_impl(db: &dyn Db, file: File) -> Result, Diagnostic> { let mut diagnostics: Vec = Vec::new(); diff --git a/crates/ty_project/src/metadata/settings.rs b/crates/ty_project/src/metadata/settings.rs index 6c88377756..11bd0f92c2 100644 --- a/crates/ty_project/src/metadata/settings.rs +++ b/crates/ty_project/src/metadata/settings.rs @@ -97,7 +97,7 @@ impl Override { } /// Resolves the settings for a given file. -#[salsa::tracked(returns(ref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), heap_size=ruff_memory_usage::heap_size)] pub(crate) fn file_settings(db: &dyn Db, file: File) -> FileSettings { let settings = db.project().settings(db); @@ -156,7 +156,7 @@ pub(crate) fn file_settings(db: &dyn Db, file: File) -> FileSettings { /// This is to make Salsa happy because it requires that queries with only a single argument /// take a salsa-struct as argument, which isn't the case here. The `()` enables salsa's /// automatic interning for the arguments. -#[salsa::tracked(heap_size=get_size2::heap_size)] +#[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] fn merge_overrides(db: &dyn Db, overrides: Vec>, _: ()) -> FileSettings { let mut overrides = overrides.into_iter().rev(); let mut merged = (*overrides.next().unwrap()).clone(); diff --git a/crates/ty_python_semantic/Cargo.toml b/crates/ty_python_semantic/Cargo.toml index 50ab542a29..ef81237b5e 100644 --- a/crates/ty_python_semantic/Cargo.toml +++ b/crates/ty_python_semantic/Cargo.toml @@ -15,6 +15,7 @@ ruff_db = { workspace = true } ruff_annotate_snippets = { workspace = true } ruff_index = { workspace = true, features = ["salsa"] } ruff_macros = { workspace = true } +ruff_memory_usage = { workspace = true } ruff_python_ast = { workspace = true, features = ["salsa"] } ruff_python_parser = { workspace = true } ruff_python_stdlib = { workspace = true } diff --git a/crates/ty_python_semantic/src/dunder_all.rs b/crates/ty_python_semantic/src/dunder_all.rs index 1cf0f50ea6..3827d9762a 100644 --- a/crates/ty_python_semantic/src/dunder_all.rs +++ b/crates/ty_python_semantic/src/dunder_all.rs @@ -26,7 +26,7 @@ fn dunder_all_names_cycle_initial(_db: &dyn Db, _file: File) -> Option Option> { let _span = tracing::trace_span!("dunder_all_names", file=?file.path(db)).entered(); diff --git a/crates/ty_python_semantic/src/module_resolver/resolver.rs b/crates/ty_python_semantic/src/module_resolver/resolver.rs index fca6ae8f1b..114289ef79 100644 --- a/crates/ty_python_semantic/src/module_resolver/resolver.rs +++ b/crates/ty_python_semantic/src/module_resolver/resolver.rs @@ -61,7 +61,7 @@ impl ModuleResolveMode { /// /// This query should not be called directly. Instead, use [`resolve_module`]. It only exists /// because Salsa requires the module name to be an ingredient. -#[salsa::tracked(heap_size=get_size2::heap_size)] +#[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] fn resolve_module_query<'db>( db: &'db dyn Db, module_name: ModuleNameIngredient<'db>, @@ -118,7 +118,7 @@ pub(crate) fn path_to_module<'db>(db: &'db dyn Db, path: &FilePath) -> Option Option> { let _span = tracing::trace_span!("file_to_module", ?file).entered(); @@ -322,7 +322,7 @@ impl SearchPaths { /// The editable-install search paths for the first `site-packages` directory /// should come between the two `site-packages` directories when it comes to /// module-resolution priority. -#[salsa::tracked(returns(deref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(deref), heap_size=ruff_memory_usage::heap_size)] pub(crate) fn dynamic_resolution_paths(db: &dyn Db) -> Vec { tracing::debug!("Resolving dynamic module resolution paths"); diff --git a/crates/ty_python_semantic/src/place.rs b/crates/ty_python_semantic/src/place.rs index 6e823ce6e5..de0c95b427 100644 --- a/crates/ty_python_semantic/src/place.rs +++ b/crates/ty_python_semantic/src/place.rs @@ -641,7 +641,7 @@ fn place_cycle_initial<'db>( Place::bound(Type::Never).into() } -#[salsa::tracked(cycle_fn=place_cycle_recover, cycle_initial=place_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(cycle_fn=place_cycle_recover, cycle_initial=place_cycle_initial, heap_size=ruff_memory_usage::heap_size)] fn place_by_id<'db>( db: &'db dyn Db, scope: ScopeId<'db>, @@ -1368,7 +1368,7 @@ mod implicit_globals { /// Conceptually this function could be a `Set` rather than a list, /// but the number of symbols declared in this scope is likely to be very small, /// so the cost of hashing the names is likely to be more expensive than it's worth. - #[salsa::tracked(returns(deref), heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(deref), heap_size=ruff_memory_usage::heap_size)] fn module_type_symbols<'db>(db: &'db dyn Db) -> smallvec::SmallVec<[ast::name::Name; 8]> { let Some(module_type) = KnownClass::ModuleType .to_class_literal(db) diff --git a/crates/ty_python_semantic/src/semantic_index.rs b/crates/ty_python_semantic/src/semantic_index.rs index 90abb34ce5..e44ba2f995 100644 --- a/crates/ty_python_semantic/src/semantic_index.rs +++ b/crates/ty_python_semantic/src/semantic_index.rs @@ -28,7 +28,6 @@ use crate::semantic_index::scope::{ use crate::semantic_index::symbol::ScopedSymbolId; use crate::semantic_index::use_def::{EnclosingSnapshotKey, ScopedEnclosingSnapshotId, UseDefMap}; use crate::semantic_model::HasTrackedScope; -use crate::util::get_size::untracked_arc_size; pub mod ast_ids; mod builder; @@ -52,7 +51,7 @@ pub(crate) use self::use_def::{ /// Returns the semantic index for `file`. /// /// Prefer using [`symbol_table`] when working with symbols from a single scope. -#[salsa::tracked(returns(ref), no_eq, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), no_eq, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn semantic_index(db: &dyn Db, file: File) -> SemanticIndex<'_> { let _span = tracing::trace_span!("semantic_index", ?file).entered(); @@ -66,7 +65,7 @@ pub(crate) fn semantic_index(db: &dyn Db, file: File) -> SemanticIndex<'_> { /// Using [`place_table`] over [`semantic_index`] has the advantage that /// Salsa can avoid invalidating dependent queries if this scope's place table /// is unchanged. -#[salsa::tracked(returns(deref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(deref), heap_size=ruff_memory_usage::heap_size)] pub(crate) fn place_table<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc { let file = scope.file(db); let _span = tracing::trace_span!("place_table", scope=?scope.as_id(), ?file).entered(); @@ -86,7 +85,7 @@ pub(crate) fn place_table<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc(db: &'db dyn Db, file: File) -> Arc> { semantic_index(db, file).imported_modules.clone() } @@ -96,8 +95,8 @@ pub(crate) fn imported_modules<'db>(db: &'db dyn Db, file: File) -> Arc(db: &'db dyn Db, scope: ScopeId<'db>) -> ArcUseDefMap<'db> { +#[salsa::tracked(returns(deref), heap_size=ruff_memory_usage::heap_size)] +pub(crate) fn use_def_map<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc> { let file = scope.file(db); let _span = tracing::trace_span!("use_def_map", scope=?scope.as_id(), ?file).entered(); let index = semantic_index(db, file); @@ -123,7 +122,7 @@ pub(crate) fn attribute_assignments<'db, 's>( let member = place_table.member_id_by_instance_attribute_name(name)?; let use_def = &index.use_def_maps[function_scope_id]; Some(( - use_def.inner.all_reachable_member_bindings(member), + use_def.all_reachable_member_bindings(member), function_scope_id, )) }) @@ -147,7 +146,7 @@ pub(crate) fn attribute_declarations<'db, 's>( let member = place_table.member_id_by_instance_attribute_name(name)?; let use_def = &index.use_def_maps[function_scope_id]; Some(( - use_def.inner.all_reachable_member_declarations(member), + use_def.all_reachable_member_declarations(member), function_scope_id, )) }) @@ -184,7 +183,7 @@ pub(crate) fn attribute_scopes<'db, 's>( } /// Returns the module global scope of `file`. -#[salsa::tracked(heap_size=get_size2::heap_size)] +#[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] pub(crate) fn global_scope(db: &dyn Db, file: File) -> ScopeId<'_> { let _span = tracing::trace_span!("global_scope", ?file).entered(); @@ -223,7 +222,7 @@ pub(crate) struct SemanticIndex<'db> { scope_ids_by_scope: IndexVec>, /// Use-def map for each scope in this file. - use_def_maps: IndexVec>, + use_def_maps: IndexVec>>, /// Lookup table to map between node ids and ast nodes. /// @@ -262,7 +261,7 @@ impl<'db> SemanticIndex<'db> { /// Use the Salsa cached [`use_def_map()`] query if you only need the /// use-def map for a single scope. #[track_caller] - pub(super) fn use_def_map(&self, scope_id: FileScopeId) -> ArcUseDefMap<'_> { + pub(super) fn use_def_map(&self, scope_id: FileScopeId) -> Arc> { self.use_def_maps[scope_id].clone() } @@ -510,7 +509,6 @@ impl<'db> SemanticIndex<'db> { }; if let Some(id) = self.enclosing_snapshots.get(&key) { return self.use_def_maps[enclosing_scope] - .inner .enclosing_snapshot(*id, key.nested_laziness); } } @@ -530,9 +528,7 @@ impl<'db> SemanticIndex<'db> { let Some(id) = self.enclosing_snapshots.get(&key) else { return EnclosingSnapshotResult::NotFound; }; - self.use_def_maps[enclosing_scope] - .inner - .enclosing_snapshot(*id, key.nested_laziness) + self.use_def_maps[enclosing_scope].enclosing_snapshot(*id, key.nested_laziness) } pub(crate) fn semantic_syntax_errors(&self) -> &[SemanticSyntaxError] { @@ -540,28 +536,6 @@ impl<'db> SemanticIndex<'db> { } } -#[derive(Debug, PartialEq, Eq, Clone, salsa::Update, get_size2::GetSize)] -pub(crate) struct ArcUseDefMap<'db> { - #[get_size(size_fn = untracked_arc_size)] - inner: Arc>, -} - -impl<'db> std::ops::Deref for ArcUseDefMap<'db> { - type Target = UseDefMap<'db>; - - fn deref(&self) -> &Self::Target { - &self.inner - } -} - -impl<'db> ArcUseDefMap<'db> { - pub(crate) fn new(inner: UseDefMap<'db>) -> Self { - Self { - inner: Arc::new(inner), - } - } -} - pub(crate) struct AncestorsIter<'a> { scopes: &'a IndexSlice, next_id: Option, diff --git a/crates/ty_python_semantic/src/semantic_index/builder.rs b/crates/ty_python_semantic/src/semantic_index/builder.rs index c545d9868f..e8a993fa10 100644 --- a/crates/ty_python_semantic/src/semantic_index/builder.rs +++ b/crates/ty_python_semantic/src/semantic_index/builder.rs @@ -47,7 +47,7 @@ use crate::semantic_index::symbol::{ScopedSymbolId, Symbol}; use crate::semantic_index::use_def::{ EnclosingSnapshotKey, FlowSnapshot, ScopedEnclosingSnapshotId, UseDefMapBuilder, }; -use crate::semantic_index::{ArcUseDefMap, ExpressionsScopeMap, SemanticIndex}; +use crate::semantic_index::{ExpressionsScopeMap, SemanticIndex}; use crate::semantic_model::HasTrackedScope; use crate::unpack::{EvaluationMode, Unpack, UnpackKind, UnpackPosition, UnpackValue}; use crate::{Db, Program}; @@ -1184,7 +1184,7 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { let mut use_def_maps: IndexVec<_, _> = self .use_def_maps .into_iter() - .map(|builder| ArcUseDefMap::new(builder.finish())) + .map(|builder| Arc::new(builder.finish())) .collect(); let mut ast_ids: IndexVec<_, _> = self diff --git a/crates/ty_python_semantic/src/semantic_index/re_exports.rs b/crates/ty_python_semantic/src/semantic_index/re_exports.rs index 909ec1a69a..9f2139637f 100644 --- a/crates/ty_python_semantic/src/semantic_index/re_exports.rs +++ b/crates/ty_python_semantic/src/semantic_index/re_exports.rs @@ -43,7 +43,7 @@ fn exports_cycle_initial(_db: &dyn Db, _file: File) -> Box<[Name]> { Box::default() } -#[salsa::tracked(returns(deref), cycle_fn=exports_cycle_recover, cycle_initial=exports_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(deref), cycle_fn=exports_cycle_recover, cycle_initial=exports_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(super) fn exported_names(db: &dyn Db, file: File) -> Box<[Name]> { let module = parsed_module(db, file).load(db); let mut finder = ExportFinder::new(db, file); diff --git a/crates/ty_python_semantic/src/suppression.rs b/crates/ty_python_semantic/src/suppression.rs index fabfc14429..9285534ada 100644 --- a/crates/ty_python_semantic/src/suppression.rs +++ b/crates/ty_python_semantic/src/suppression.rs @@ -86,7 +86,7 @@ declare_lint! { } } -#[salsa::tracked(returns(ref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), heap_size=ruff_memory_usage::heap_size)] pub(crate) fn suppressions(db: &dyn Db, file: File) -> Suppressions { let parsed = parsed_module(db, file).load(db); let source = source_text(db, file); diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs index 5d5852a31f..3bccbf2a1b 100644 --- a/crates/ty_python_semantic/src/types.rs +++ b/crates/ty_python_semantic/src/types.rs @@ -2634,7 +2634,7 @@ impl<'db> Type<'db> { } } - #[salsa::tracked(heap_size=get_size2::heap_size)] + #[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] #[allow(unused_variables)] // If we choose name `_unit`, the macro will generate code that uses `_unit`, causing clippy to fail. fn lookup_dunder_new(self, db: &'db dyn Db, unit: ()) -> Option> { @@ -2655,7 +2655,7 @@ impl<'db> Type<'db> { self.class_member_with_policy(db, name, MemberLookupPolicy::default()) } - #[salsa::tracked(cycle_fn=class_lookup_cycle_recover, cycle_initial=class_lookup_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(cycle_fn=class_lookup_cycle_recover, cycle_initial=class_lookup_cycle_initial, heap_size=ruff_memory_usage::heap_size)] fn class_member_with_policy( self, db: &'db dyn Db, @@ -2818,7 +2818,7 @@ impl<'db> Type<'db> { /// that `self` represents: (1) a data descriptor or (2) a non-data descriptor / normal attribute. /// /// If `__get__` is not defined on the meta-type, this method returns `None`. - #[salsa::tracked(heap_size=get_size2::heap_size)] + #[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] pub(crate) fn try_call_dunder_get( self, db: &'db dyn Db, @@ -3111,7 +3111,7 @@ impl<'db> Type<'db> { /// Similar to [`Type::member`], but allows the caller to specify what policy should be used /// when looking up attributes. See [`MemberLookupPolicy`] for more information. - #[salsa::tracked(cycle_fn=member_lookup_cycle_recover, cycle_initial=member_lookup_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(cycle_fn=member_lookup_cycle_recover, cycle_initial=member_lookup_cycle_initial, heap_size=ruff_memory_usage::heap_size)] fn member_lookup_with_policy( self, db: &'db dyn Db, @@ -5683,7 +5683,7 @@ impl<'db> Type<'db> { /// Note that this does not specialize generic classes, functions, or type aliases! That is a /// different operation that is performed explicitly (via a subscript operation), or implicitly /// via a call to the generic object. - #[salsa::tracked(heap_size=get_size2::heap_size)] + #[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] pub fn apply_specialization( self, db: &'db dyn Db, @@ -8389,7 +8389,7 @@ impl<'db> PEP695TypeAliasType<'db> { semantic_index(db, scope.file(db)).expect_single_definition(type_alias_stmt_node) } - #[salsa::tracked(heap_size=get_size2::heap_size)] + #[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] pub(crate) fn value_type(self, db: &'db dyn Db) -> Type<'db> { let scope = self.rhs_scope(db); let module = parsed_module(db, scope.file(db)).load(db); diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs index 0ce8f98807..7dc9d37ea7 100644 --- a/crates/ty_python_semantic/src/types/class.rs +++ b/crates/ty_python_semantic/src/types/class.rs @@ -1192,7 +1192,7 @@ impl<'db> ClassLiteral<'db> { self.pep695_generic_context(db).is_some() } - #[salsa::tracked(cycle_fn=pep695_generic_context_cycle_recover, cycle_initial=pep695_generic_context_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(cycle_fn=pep695_generic_context_cycle_recover, cycle_initial=pep695_generic_context_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn pep695_generic_context(self, db: &'db dyn Db) -> Option> { let scope = self.body_scope(db); let parsed = parsed_module(db, scope.file(db)).load(db); @@ -1302,7 +1302,7 @@ impl<'db> ClassLiteral<'db> { /// /// Were this not a salsa query, then the calling query /// would depend on the class's AST and rerun for every change in that file. - #[salsa::tracked(returns(deref), cycle_fn=explicit_bases_cycle_recover, cycle_initial=explicit_bases_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(deref), cycle_fn=explicit_bases_cycle_recover, cycle_initial=explicit_bases_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(super) fn explicit_bases(self, db: &'db dyn Db) -> Box<[Type<'db>]> { tracing::trace!("ClassLiteral::explicit_bases_query: {}", self.name(db)); @@ -1392,7 +1392,7 @@ impl<'db> ClassLiteral<'db> { } /// Return the types of the decorators on this class - #[salsa::tracked(returns(deref), heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(deref), heap_size=ruff_memory_usage::heap_size)] fn decorators(self, db: &'db dyn Db) -> Box<[Type<'db>]> { tracing::trace!("ClassLiteral::decorators: {}", self.name(db)); @@ -1441,7 +1441,7 @@ impl<'db> ClassLiteral<'db> { /// attribute on a class at runtime. /// /// [method resolution order]: https://docs.python.org/3/glossary.html#term-method-resolution-order - #[salsa::tracked(returns(as_ref), cycle_fn=try_mro_cycle_recover, cycle_initial=try_mro_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(as_ref), cycle_fn=try_mro_cycle_recover, cycle_initial=try_mro_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(super) fn try_mro( self, db: &'db dyn Db, @@ -1485,7 +1485,7 @@ impl<'db> ClassLiteral<'db> { #[salsa::tracked( cycle_fn=is_typed_dict_cycle_recover, cycle_initial=is_typed_dict_cycle_initial, - heap_size=get_size2::heap_size + heap_size=ruff_memory_usage::heap_size )] pub(super) fn is_typed_dict(self, db: &'db dyn Db) -> bool { if let Some(known) = self.known(db) { @@ -1537,7 +1537,7 @@ impl<'db> ClassLiteral<'db> { #[salsa::tracked( cycle_fn=try_metaclass_cycle_recover, cycle_initial=try_metaclass_cycle_initial, - heap_size=get_size2::heap_size, + heap_size=ruff_memory_usage::heap_size, )] pub(super) fn try_metaclass( self, @@ -2791,7 +2791,7 @@ impl<'db> ClassLiteral<'db> { /// /// A class definition like this will fail at runtime, /// but we must be resilient to it or we could panic. - #[salsa::tracked(cycle_fn=inheritance_cycle_recover, cycle_initial=inheritance_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(cycle_fn=inheritance_cycle_recover, cycle_initial=inheritance_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(super) fn inheritance_cycle(self, db: &'db dyn Db) -> Option { /// Return `true` if the class is cyclically defined. /// diff --git a/crates/ty_python_semantic/src/types/enums.rs b/crates/ty_python_semantic/src/types/enums.rs index cdc01e479d..5eb183dade 100644 --- a/crates/ty_python_semantic/src/types/enums.rs +++ b/crates/ty_python_semantic/src/types/enums.rs @@ -53,7 +53,7 @@ fn enum_metadata_cycle_initial(_db: &dyn Db, _class: ClassLiteral<'_>) -> Option /// List all members of an enum. #[allow(clippy::ref_option, clippy::unnecessary_wraps)] -#[salsa::tracked(returns(as_ref), cycle_fn=enum_metadata_cycle_recover, cycle_initial=enum_metadata_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(as_ref), cycle_fn=enum_metadata_cycle_recover, cycle_initial=enum_metadata_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn enum_metadata<'db>( db: &'db dyn Db, class: ClassLiteral<'db>, diff --git a/crates/ty_python_semantic/src/types/function.rs b/crates/ty_python_semantic/src/types/function.rs index eaa2f1053a..9feaadb9a4 100644 --- a/crates/ty_python_semantic/src/types/function.rs +++ b/crates/ty_python_semantic/src/types/function.rs @@ -499,7 +499,7 @@ impl<'db> FunctionLiteral<'db> { self.last_definition(db).spans(db) } - #[salsa::tracked(returns(ref), heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(ref), heap_size=ruff_memory_usage::heap_size)] fn overloads_and_implementation( self, db: &'db dyn Db, @@ -790,7 +790,7 @@ impl<'db> FunctionType<'db> { /// /// Were this not a salsa query, then the calling query /// would depend on the function's AST and rerun for every change in that file. - #[salsa::tracked(returns(ref), cycle_fn=signature_cycle_recover, cycle_initial=signature_cycle_initial, heap_size=get_size2::heap_size)] + #[salsa::tracked(returns(ref), cycle_fn=signature_cycle_recover, cycle_initial=signature_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn signature(self, db: &'db dyn Db) -> CallableSignature<'db> { self.literal(db).signature(db, self.type_mappings(db)) } diff --git a/crates/ty_python_semantic/src/types/infer.rs b/crates/ty_python_semantic/src/types/infer.rs index d1dec5e148..b618a6a692 100644 --- a/crates/ty_python_semantic/src/types/infer.rs +++ b/crates/ty_python_semantic/src/types/infer.rs @@ -131,7 +131,7 @@ use crate::{Db, FxOrderSet, Program}; /// Infer all types for a [`ScopeId`], including all definitions and expressions in that scope. /// Use when checking a scope, or needing to provide a type for an arbitrary expression in the /// scope. -#[salsa::tracked(returns(ref), cycle_fn=scope_cycle_recover, cycle_initial=scope_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), cycle_fn=scope_cycle_recover, cycle_initial=scope_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn infer_scope_types<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> ScopeInference<'db> { let file = scope.file(db); let _span = tracing::trace_span!("infer_scope_types", scope=?scope.as_id(), ?file).entered(); @@ -160,7 +160,7 @@ fn scope_cycle_initial<'db>(_db: &'db dyn Db, scope: ScopeId<'db>) -> ScopeInfer /// Infer all types for a [`Definition`] (including sub-expressions). /// Use when resolving a place use or public type of a place. -#[salsa::tracked(returns(ref), cycle_fn=definition_cycle_recover, cycle_initial=definition_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), cycle_fn=definition_cycle_recover, cycle_initial=definition_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn infer_definition_types<'db>( db: &'db dyn Db, definition: Definition<'db>, @@ -200,7 +200,7 @@ fn definition_cycle_initial<'db>( /// /// Deferred expressions are type expressions (annotations, base classes, aliases...) in a stub /// file, or in a file with `from __future__ import annotations`, or stringified annotations. -#[salsa::tracked(returns(ref), cycle_fn=deferred_cycle_recover, cycle_initial=deferred_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), cycle_fn=deferred_cycle_recover, cycle_initial=deferred_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn infer_deferred_types<'db>( db: &'db dyn Db, definition: Definition<'db>, @@ -241,7 +241,7 @@ fn deferred_cycle_initial<'db>( /// Use rarely; only for cases where we'd otherwise risk double-inferring an expression: RHS of an /// assignment, which might be unpacking/multi-target and thus part of multiple definitions, or a /// type narrowing guard expression (e.g. if statement test node). -#[salsa::tracked(returns(ref), cycle_fn=expression_cycle_recover, cycle_initial=expression_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), cycle_fn=expression_cycle_recover, cycle_initial=expression_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn infer_expression_types<'db>( db: &'db dyn Db, expression: Expression<'db>, @@ -299,7 +299,7 @@ pub(super) fn infer_same_file_expression_type<'db>( /// /// Use [`infer_same_file_expression_type`] if it is guaranteed that `expression` is in the same /// to avoid unnecessary salsa ingredients. This is normally the case inside the `TypeInferenceBuilder`. -#[salsa::tracked(cycle_fn=single_expression_cycle_recover, cycle_initial=single_expression_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(cycle_fn=single_expression_cycle_recover, cycle_initial=single_expression_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(crate) fn infer_expression_type<'db>( db: &'db dyn Db, expression: Expression<'db>, @@ -333,7 +333,7 @@ fn single_expression_cycle_initial<'db>( /// involved in an unpacking operation. It returns a result-like object that can be used to get the /// type of the variables involved in this unpacking along with any violations that are detected /// during this unpacking. -#[salsa::tracked(returns(ref), cycle_fn=unpack_cycle_recover, cycle_initial=unpack_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(ref), cycle_fn=unpack_cycle_recover, cycle_initial=unpack_cycle_initial, heap_size=ruff_memory_usage::heap_size)] pub(super) fn infer_unpack_types<'db>(db: &'db dyn Db, unpack: Unpack<'db>) -> UnpackResult<'db> { let file = unpack.file(db); let module = parsed_module(db, file).load(db); diff --git a/crates/ty_python_semantic/src/types/narrow.rs b/crates/ty_python_semantic/src/types/narrow.rs index 2147318b3e..7db71ccb00 100644 --- a/crates/ty_python_semantic/src/types/narrow.rs +++ b/crates/ty_python_semantic/src/types/narrow.rs @@ -72,7 +72,7 @@ pub(crate) fn infer_narrowing_constraint<'db>( } } -#[salsa::tracked(returns(as_ref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(as_ref), heap_size=ruff_memory_usage::heap_size)] fn all_narrowing_constraints_for_pattern<'db>( db: &'db dyn Db, pattern: PatternPredicate<'db>, @@ -85,7 +85,7 @@ fn all_narrowing_constraints_for_pattern<'db>( returns(as_ref), cycle_fn=constraints_for_expression_cycle_recover, cycle_initial=constraints_for_expression_cycle_initial, - heap_size=get_size2::heap_size, + heap_size=ruff_memory_usage::heap_size, )] fn all_narrowing_constraints_for_expression<'db>( db: &'db dyn Db, @@ -100,7 +100,7 @@ fn all_narrowing_constraints_for_expression<'db>( returns(as_ref), cycle_fn=negative_constraints_for_expression_cycle_recover, cycle_initial=negative_constraints_for_expression_cycle_initial, - heap_size=get_size2::heap_size, + heap_size=ruff_memory_usage::heap_size, )] fn all_negative_narrowing_constraints_for_expression<'db>( db: &'db dyn Db, @@ -111,7 +111,7 @@ fn all_negative_narrowing_constraints_for_expression<'db>( .finish() } -#[salsa::tracked(returns(as_ref), heap_size=get_size2::heap_size)] +#[salsa::tracked(returns(as_ref), heap_size=ruff_memory_usage::heap_size)] fn all_negative_narrowing_constraints_for_pattern<'db>( db: &'db dyn Db, pattern: PatternPredicate<'db>, diff --git a/crates/ty_python_semantic/src/types/property_tests/type_generation.rs b/crates/ty_python_semantic/src/types/property_tests/type_generation.rs index 55452144a6..012b37ecce 100644 --- a/crates/ty_python_semantic/src/types/property_tests/type_generation.rs +++ b/crates/ty_python_semantic/src/types/property_tests/type_generation.rs @@ -115,7 +115,7 @@ enum ParamKind { KeywordVariadic, } -#[salsa::tracked(heap_size=get_size2::heap_size)] +#[salsa::tracked(heap_size=ruff_memory_usage::heap_size)] fn create_bound_method<'db>( db: &'db dyn Db, function: Type<'db>, diff --git a/crates/ty_python_semantic/src/types/protocol_class.rs b/crates/ty_python_semantic/src/types/protocol_class.rs index 6525be8181..25398eeadf 100644 --- a/crates/ty_python_semantic/src/types/protocol_class.rs +++ b/crates/ty_python_semantic/src/types/protocol_class.rs @@ -514,7 +514,7 @@ enum BoundOnClass { } /// Inner Salsa query for [`ProtocolClassLiteral::interface`]. -#[salsa::tracked(cycle_fn=proto_interface_cycle_recover, cycle_initial=proto_interface_cycle_initial, heap_size=get_size2::heap_size)] +#[salsa::tracked(cycle_fn=proto_interface_cycle_recover, cycle_initial=proto_interface_cycle_initial, heap_size=ruff_memory_usage::heap_size)] fn cached_protocol_interface<'db>( db: &'db dyn Db, class: ClassLiteral<'db>, diff --git a/crates/ty_python_semantic/src/util/get_size.rs b/crates/ty_python_semantic/src/util/get_size.rs deleted file mode 100644 index d77cf5c14c..0000000000 --- a/crates/ty_python_semantic/src/util/get_size.rs +++ /dev/null @@ -1,15 +0,0 @@ -use std::sync::Arc; - -use get_size2::GetSize; - -/// By default, `Arc: GetSize` requires `T: 'static` to enable tracking references -/// of the `Arc` and avoid double-counting. This method opts out of that behavior and -/// removes the `'static` requirement. -/// -/// This method will just return the heap-size of the inner `T`. -pub(crate) fn untracked_arc_size(arc: &Arc) -> usize -where - T: GetSize, -{ - T::get_heap_size(&**arc) -} diff --git a/crates/ty_python_semantic/src/util/mod.rs b/crates/ty_python_semantic/src/util/mod.rs index 5ba24ddaac..54555cd617 100644 --- a/crates/ty_python_semantic/src/util/mod.rs +++ b/crates/ty_python_semantic/src/util/mod.rs @@ -1,3 +1,2 @@ pub(crate) mod diagnostics; -pub(crate) mod get_size; pub(crate) mod subscript; diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml index b71a962eae..31eee12ab9 100644 --- a/fuzz/Cargo.toml +++ b/fuzz/Cargo.toml @@ -30,7 +30,7 @@ ty_python_semantic = { path = "../crates/ty_python_semantic" } ty_vendored = { path = "../crates/ty_vendored" } libfuzzer-sys = { git = "https://github.com/rust-fuzz/libfuzzer", default-features = false } -salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "d66fe331d546216132ace503512b94d5c68d2c50", default-features = false, features = [ +salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "b121ee46c4483ba74c19e933a3522bd548eb7343", default-features = false, features = [ "compact_str", "macros", "salsa_unstable",