chore: configure centralized clippy lints

- Add [workspace.lints] with clippy::all, pedantic, nursery, cargo
- Forbid unsafe_code at workspace level
- Add [lints] workspace = true to all crates
- Apply clippy --fix for auto-fixable issues
- Allow noisy lints for incremental improvement
- Fix ref_option in npm parser
- Fix unnecessary_literal_bound in tests

Author: bug-ops

Cargo.toml

@@ -45,6 +45,104 @@ tracing-subscriber = "0.3"
 urlencoding = "2.1"
 zed_extension_api = "0.7"
 
+[workspace.lints.rust]
+unsafe_code = "forbid"
+missing_docs = "allow"
+missing_debug_implementations = "allow"
+unreachable_pub = "warn"
+
+[workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+
+# Allowed lints - too noisy for this codebase
+module_name_repetitions = "allow"
+similar_names = "allow"
+too_many_lines = "allow"
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+single_match_else = "allow"
+
+# Documentation lints - allow for now, can enable incrementally
+doc_markdown = "allow"
+missing_docs_in_private_items = "allow"
+
+# Cargo lints - metadata can be added later
+cargo_common_metadata = "allow"
+
+# Nursery lints that are too pedantic
+option_if_let_else = "allow"
+future_not_send = "allow"
+redundant_pub_crate = "allow"
+
+# Pattern-matching lints - allow for now
+wildcard_enum_match_arm = "allow"
+redundant_else = "allow"
+
+# Style lints - allow for readability
+manual_let_else = "allow"
+items_after_statements = "allow"
+
+# Type conversion lints - allow where intentional
+cast_possible_truncation = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+
+# Nursery performance lints that need review
+significant_drop_tightening = "allow"
+
+# Cargo lints that conflict with workspace setup
+multiple_crate_versions = "allow"
+
+# Style lints - allow for now, can be fixed incrementally
+uninlined_format_args = "allow"
+explicit_iter_loop = "allow"
+redundant_closure_for_method_calls = "allow"
+match_wildcard_for_single_variants = "allow"
+
+# Function lints - allow for now
+missing_const_for_fn = "allow"
+unnecessary_wraps = "allow"
+
+# LazyLock migration - allow until we can target newer MSRV
+non_std_lazy_statics = "allow"
+
+# HashMap generics - too noisy for internal APIs
+implicit_hasher = "allow"
+
+# Performance lints that are pedantic
+map_unwrap_or = "allow"
+needless_collect = "allow"
+or_fun_call = "allow"
+format_push_string = "allow"
+
+# Documentation lints
+doc_link_with_quotes = "allow"
+
+# Derive lints - can be fixed incrementally
+derive_partial_eq_without_eq = "allow"
+
+# Test-specific lints
+used_underscore_binding = "allow"
+ignore_without_reason = "allow"
+
+# API design lints that need review
+unused_self = "allow"
+unused_async = "allow"
+
+# Pattern matching lints
+match_same_arms = "allow"
+
+# File extension checks - too strict
+case_sensitive_file_extension_comparisons = "allow"
+
+# Style preferences
+default_trait_access = "allow"
+needless_pass_by_value = "allow"
+
 [profile.release]
 lto = true
 codegen-units = 1

crates/deps-cargo/Cargo.toml

@@ -9,6 +9,9 @@ repository.workspace = true
 description = "Cargo.toml support for deps-lsp"
 publish = true
 
+[lints]
+workspace = true
+
 [dependencies]
 deps-core = { workspace = true }
 async-trait = { workspace = true }

crates/deps-cargo/benches/cargo_benchmarks.rs

@@ -108,7 +108,7 @@ resolver = "2"
                 i % 20
             ));
         } else if i % 3 == 1 {
-            content.push_str(&format!("dep{} = {{ workspace = true }}\n", i));
+            content.push_str(&format!("dep{i} = {{ workspace = true }}\n"));
         } else {
             content.push_str(&format!("dep{} = \"1.{}.0\"\n", i, i % 20));
         }
@@ -145,24 +145,24 @@ fn bench_cargo_parsing(c: &mut Criterion) {
 
     group.bench_function("small_5_deps", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(SMALL_CARGO_TOML), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(SMALL_CARGO_TOML), black_box(&url)));
     });
 
     group.bench_function("medium_25_deps", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(MEDIUM_CARGO_TOML), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(MEDIUM_CARGO_TOML), black_box(&url)));
     });
 
     let large_toml = generate_large_cargo_toml();
     group.bench_function("large_100_deps", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(&large_toml), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(&large_toml), black_box(&url)));
     });
 
     let workspace_toml = generate_workspace_cargo_toml();
     group.bench_function("workspace_100_deps", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(&workspace_toml), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(&workspace_toml), black_box(&url)));
     });
 
     group.finish();
@@ -188,12 +188,12 @@ serde = { version = "1.0", features = ["derive", "std"], default-features = fals
 
     group.bench_function("inline_dependency", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(inline), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(inline), black_box(&url)));
     });
 
     group.bench_function("table_dependency", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(table), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(table), black_box(&url)));
     });
 
     group.finish();
@@ -226,15 +226,14 @@ fn bench_registry_parsing(c: &mut Criterion) {
                 .lines()
                 .filter_map(|line| serde_json::from_str(line).ok())
                 .collect();
-        })
+        });
     });
 
     // Generate large sparse index response (100 versions)
     let mut large_index = String::new();
     for i in 0..100 {
         large_index.push_str(&format!(
-            r#"{{"name":"crate","vers":"1.0.{}","deps":[],"cksum":"abc{}","features":{{}},"yanked":false}}"#,
-            i, i
+            r#"{{"name":"crate","vers":"1.0.{i}","deps":[],"cksum":"abc{i}","features":{{}},"yanked":false}}"#
         ));
         large_index.push('\n');
     }
@@ -245,7 +244,7 @@ fn bench_registry_parsing(c: &mut Criterion) {
                 .lines()
                 .filter_map(|line| serde_json::from_str(line).ok())
                 .collect();
-        })
+        });
     });
 
     group.finish();
@@ -271,13 +270,13 @@ fn bench_version_matching(c: &mut Criterion) {
     // Simple version requirement
     let simple_req = VersionReq::parse("1.0").unwrap();
     group.bench_function("simple_version_req", |b| {
-        b.iter(|| simple_req.matches(black_box(&latest)))
+        b.iter(|| simple_req.matches(black_box(&latest)));
     });
 
     // Complex version requirement (multiple constraints)
     let complex_req = VersionReq::parse(">=1.0.100, <2.0").unwrap();
     group.bench_function("complex_version_req", |b| {
-        b.iter(|| complex_req.matches(black_box(&latest)))
+        b.iter(|| complex_req.matches(black_box(&latest)));
     });
 
     // Find latest matching version
@@ -288,7 +287,7 @@ fn bench_version_matching(c: &mut Criterion) {
                 .filter(|v| simple_req.matches(v))
                 .max()
                 .cloned()
-        })
+        });
     });
 
     group.finish();
@@ -318,8 +317,8 @@ serde = { version = "1.0", features = ["derive"] }"#,
         ),
         (
             "workspace_inheritance",
-            r#"[dependencies]
-serde = { workspace = true }"#,
+            r"[dependencies]
+serde = { workspace = true }",
         ),
         (
             "git_dependency",
@@ -344,7 +343,7 @@ default-features = false"#,
     for (name, content) in formats {
         group.bench_with_input(BenchmarkId::from_parameter(name), &content, |b, content| {
             let url = test_url();
-            b.iter(|| parse_cargo_toml(black_box(content), black_box(&url)))
+            b.iter(|| parse_cargo_toml(black_box(content), black_box(&url)));
         });
     }
 
@@ -367,7 +366,7 @@ tokio = "1.0"  # Зависимость с кириллицей
 
     c.bench_function("unicode_parsing", |b| {
         let url = test_url();
-        b.iter(|| parse_cargo_toml(black_box(unicode_toml), black_box(&url)))
+        b.iter(|| parse_cargo_toml(black_box(unicode_toml), black_box(&url)));
     });
 }
 

crates/deps-cargo/src/ecosystem.rs

@@ -340,8 +340,8 @@ mod tests {
         }
 
         fn uri(&self) -> &Uri {
-            static URI: once_cell::sync::Lazy<Uri> =
-                once_cell::sync::Lazy::new(|| Uri::from_file_path("/test/Cargo.toml").unwrap());
+            static URI: std::sync::LazyLock<Uri> =
+                std::sync::LazyLock::new(|| Uri::from_file_path("/test/Cargo.toml").unwrap());
             &URI
         }
 
@@ -734,6 +734,6 @@ mod tests {
         // Real packages with special characters
         let results = ecosystem.complete_package_names("tokio-ut").await;
         assert!(!results.is_empty());
-        assert!(results.iter().any(|r| r.label.contains("-")));
+        assert!(results.iter().any(|r| r.label.contains('-')));
     }
 }

crates/deps-cargo/src/error.rs

@@ -137,20 +137,18 @@ impl CargoError {
 impl From<deps_core::DepsError> for CargoError {
     fn from(err: deps_core::DepsError) -> Self {
         match err {
-            deps_core::DepsError::ParseError { source, .. } => {
-                CargoError::CacheError(source.to_string())
-            }
-            deps_core::DepsError::CacheError(msg) => CargoError::CacheError(msg),
-            deps_core::DepsError::InvalidVersionReq(msg) => CargoError::InvalidVersionSpecifier {
+            deps_core::DepsError::ParseError { source, .. } => Self::CacheError(source.to_string()),
+            deps_core::DepsError::CacheError(msg) => Self::CacheError(msg),
+            deps_core::DepsError::InvalidVersionReq(msg) => Self::InvalidVersionSpecifier {
                 specifier: String::new(),
                 message: msg,
             },
-            deps_core::DepsError::Io(e) => CargoError::Io(e),
-            deps_core::DepsError::Json(e) => CargoError::ApiResponseError {
+            deps_core::DepsError::Io(e) => Self::Io(e),
+            deps_core::DepsError::Json(e) => Self::ApiResponseError {
                 package: String::new(),
                 source: e,
             },
-            other => CargoError::CacheError(other.to_string()),
+            other => Self::CacheError(other.to_string()),
         }
     }
 }
@@ -159,32 +157,28 @@ impl From<deps_core::DepsError> for CargoError {
 impl From<CargoError> for deps_core::DepsError {
     fn from(err: CargoError) -> Self {
         match err {
-            CargoError::TomlParseError { source } => deps_core::DepsError::ParseError {
+            CargoError::TomlParseError { source } => Self::ParseError {
                 file_type: "Cargo.toml".into(),
                 source: Box::new(source),
             },
-            CargoError::InvalidVersionSpecifier { message, .. } => {
-                deps_core::DepsError::InvalidVersionReq(message)
-            }
+            CargoError::InvalidVersionSpecifier { message, .. } => Self::InvalidVersionReq(message),
             CargoError::PackageNotFound { package } => {
-                deps_core::DepsError::CacheError(format!("Crate '{}' not found", package))
+                Self::CacheError(format!("Crate '{package}' not found"))
             }
-            CargoError::RegistryError { package, source } => deps_core::DepsError::ParseError {
-                file_type: format!("crates.io registry for {}", package),
+            CargoError::RegistryError { package, source } => Self::ParseError {
+                file_type: format!("crates.io registry for {package}"),
                 source,
             },
-            CargoError::ApiResponseError { source, .. } => deps_core::DepsError::Json(source),
-            CargoError::InvalidStructure { message } => deps_core::DepsError::CacheError(message),
+            CargoError::ApiResponseError { source, .. } => Self::Json(source),
+            CargoError::InvalidStructure { message } => Self::CacheError(message),
             CargoError::MissingField { section, field } => {
-                deps_core::DepsError::CacheError(format!("Missing '{}' in {}", field, section))
-            }
-            CargoError::WorkspaceError { message } => deps_core::DepsError::CacheError(message),
-            CargoError::InvalidUri { uri } => {
-                deps_core::DepsError::CacheError(format!("Invalid URI: {}", uri))
+                Self::CacheError(format!("Missing '{field}' in {section}"))
             }
-            CargoError::CacheError(msg) => deps_core::DepsError::CacheError(msg),
-            CargoError::Io(e) => deps_core::DepsError::Io(e),
-            CargoError::Other(e) => deps_core::DepsError::CacheError(e.to_string()),
+            CargoError::WorkspaceError { message } => Self::CacheError(message),
+            CargoError::InvalidUri { uri } => Self::CacheError(format!("Invalid URI: {uri}")),
+            CargoError::CacheError(msg) => Self::CacheError(msg),
+            CargoError::Io(e) => Self::Io(e),
+            CargoError::Other(e) => Self::CacheError(e.to_string()),
         }
     }
 }

crates/deps-cargo/src/formatter.rs

@@ -4,11 +4,11 @@ pub struct CargoFormatter;
 
 impl EcosystemFormatter for CargoFormatter {
     fn format_version_for_code_action(&self, version: &str) -> String {
-        format!("\"{}\"", version)
+        format!("\"{version}\"")
     }
 
     fn package_url(&self, name: &str) -> String {
-        format!("https://crates.io/crates/{}", name)
+        format!("https://crates.io/crates/{name}")
     }
 }
 

crates/deps-cargo/src/handler.rs

@@ -51,7 +51,7 @@ impl EcosystemHandler for CargoHandler {
     }
 
     fn format_version_for_edit(_dep: &Self::Dependency, version: &str) -> String {
-        format!("\"{}\"", version)
+        format!("\"{version}\"")
     }
 
     fn is_deprecated(version: &crate::CargoVersion) -> bool {

crates/deps-cargo/src/lockfile.rs

@@ -99,7 +99,7 @@ impl LockFileProvider for CargoLockParser {
             return Ok(packages);
         };
 
-        for table in package_array.iter() {
+        for table in package_array {
             // Extract required fields
             let Some(name) = table.get("name").and_then(|v: &toml_edit::Item| v.as_str()) else {
                 tracing::warn!("Package missing name field");
@@ -338,9 +338,9 @@ source = "git+https://github.com/user/repo#abc123"
 
     #[tokio::test]
     async fn test_parse_empty_cargo_lock() {
-        let lockfile_content = r#"
+        let lockfile_content = r"
 version = 4
-"#;
+";
 
         let temp_dir = tempfile::tempdir().unwrap();
         let lockfile_path = temp_dir.path().join("Cargo.lock");