refactor(core): remove legacy traits, add Ecosystem defaults, replace async_trait (#70)

Remove ~2000 lines of deprecated handler.rs and legacy trait system
(PackageRegistry, VersionInfo, PackageMetadata, EcosystemHandler).

Add default method implementations to Ecosystem trait for
generate_inlay_hints, generate_hover, generate_code_actions,
generate_diagnostics — eliminating ~400 lines of identical boilerplate
across 8 ecosystem crates.

Replace async_trait proc-macro with explicit BoxFuture pattern across
Ecosystem, Registry, and LockFileProvider traits and all implementations.

Centralize test mock types (MockDep, MockParseResult) in deps-core.

Closes #68

Author: bug-ops

CHANGELOG.md

@@ -25,6 +25,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Remove `toml_edit` from workspace dependencies (all TOML parsers now use `toml-span`)
 - Extract `LineOffsetTable` and `position_in_range` to deps-core for reuse across ecosystems
 - Extract `complete_package_names_generic` to deps-core completion module
+- **Architectural refactoring** — Remove legacy trait system and eliminate code duplication across 8 ecosystem crates (closes #68):
+  - Delete `handler.rs` and legacy `PackageRegistry`, `VersionInfo`, `PackageMetadata` traits from deps-core
+  - Add `fn formatter(&self)` required method to `Ecosystem` trait; default LSP handler implementations for `generate_inlay_hints`, `generate_hover`, `generate_code_actions`, `generate_diagnostics` — eliminating ~400 duplicate lines across ecosystems
+  - Replace `#[async_trait]` with `BoxFuture` pattern in `Ecosystem`, `Registry`, and `LockFileProvider` traits (dyn-safe, no async_trait allocations)
+  - Centralize `MockDep`/`MockParseResult` test helpers in `deps-core::lsp_helpers` tests (was duplicated 11 times)
+  - Remove conflicting duplicate `Version`/`Metadata` impls from `deps-dart` and `deps-bundler` types modules
 
 ## [0.7.1] - 2026-02-22
 

crates/deps-bundler/src/ecosystem.rs

@@ -1,15 +1,11 @@
 //! Bundler ecosystem implementation for deps-lsp.
 
-use async_trait::async_trait;
 use std::any::Any;
-use std::collections::HashMap;
 use std::sync::Arc;
-use tower_lsp_server::ls_types::{
-    CodeAction, CompletionItem, Diagnostic, Hover, InlayHint, Position, Uri,
-};
+use tower_lsp_server::ls_types::{CompletionItem, Position, Uri};
 
 use deps_core::{
-    Ecosystem, EcosystemConfig, ParseResult as ParseResultTrait, Registry, Result, lsp_helpers,
+    Ecosystem, ParseResult as ParseResultTrait, Registry, Result, lsp_helpers::EcosystemFormatter,
 };
 
 use crate::formatter::BundlerFormatter;
@@ -77,7 +73,6 @@ impl BundlerEcosystem {
     }
 }
 
-#[async_trait]
 impl Ecosystem for BundlerEcosystem {
     fn id(&self) -> &'static str {
         "bundler"
@@ -95,9 +90,15 @@ impl Ecosystem for BundlerEcosystem {
         &["Gemfile.lock"]
     }
 
-    async fn parse_manifest(&self, content: &str, uri: &Uri) -> Result<Box<dyn ParseResultTrait>> {
-        let result = crate::parser::parse_gemfile(content, uri)?;
-        Ok(Box::new(result))
+    fn parse_manifest<'a>(
+        &'a self,
+        content: &'a str,
+        uri: &'a Uri,
+    ) -> deps_core::ecosystem::BoxFuture<'a, Result<Box<dyn ParseResultTrait>>> {
+        Box::pin(async move {
+            let result = crate::parser::parse_gemfile(content, uri)?;
+            Ok(Box::new(result) as Box<dyn ParseResultTrait>)
+        })
     }
 
     fn registry(&self) -> Arc<dyn Registry> {
@@ -108,92 +109,32 @@ impl Ecosystem for BundlerEcosystem {
         Some(Arc::new(crate::lockfile::GemfileLockParser))
     }
 
-    async fn generate_inlay_hints(
-        &self,
-        parse_result: &dyn ParseResultTrait,
-        cached_versions: &HashMap<String, String>,
-        resolved_versions: &HashMap<String, String>,
-        loading_state: deps_core::LoadingState,
-        config: &EcosystemConfig,
-    ) -> Vec<InlayHint> {
-        lsp_helpers::generate_inlay_hints(
-            parse_result,
-            cached_versions,
-            resolved_versions,
-            loading_state,
-            config,
-            &self.formatter,
-        )
-    }
-
-    async fn generate_hover(
-        &self,
-        parse_result: &dyn ParseResultTrait,
-        position: Position,
-        cached_versions: &HashMap<String, String>,
-        resolved_versions: &HashMap<String, String>,
-    ) -> Option<Hover> {
-        lsp_helpers::generate_hover(
-            parse_result,
-            position,
-            cached_versions,
-            resolved_versions,
-            self.registry.as_ref(),
-            &self.formatter,
-        )
-        .await
+    fn formatter(&self) -> &dyn EcosystemFormatter {
+        &self.formatter
     }
 
-    async fn generate_code_actions(
-        &self,
-        parse_result: &dyn ParseResultTrait,
+    fn generate_completions<'a>(
+        &'a self,
+        parse_result: &'a dyn ParseResultTrait,
         position: Position,
-        _cached_versions: &HashMap<String, String>,
-        uri: &Uri,
-    ) -> Vec<CodeAction> {
-        lsp_helpers::generate_code_actions(
-            parse_result,
-            position,
-            uri,
-            self.registry.as_ref(),
-            &self.formatter,
-        )
-        .await
-    }
-
-    async fn generate_diagnostics(
-        &self,
-        parse_result: &dyn ParseResultTrait,
-        cached_versions: &HashMap<String, String>,
-        resolved_versions: &HashMap<String, String>,
-        _uri: &Uri,
-    ) -> Vec<Diagnostic> {
-        lsp_helpers::generate_diagnostics_from_cache(
-            parse_result,
-            cached_versions,
-            resolved_versions,
-            &self.formatter,
-        )
-    }
-
-    async fn generate_completions(
-        &self,
-        parse_result: &dyn ParseResultTrait,
-        position: Position,
-        content: &str,
-    ) -> Vec<CompletionItem> {
-        use deps_core::completion::{CompletionContext, detect_completion_context};
-
-        let context = detect_completion_context(parse_result, position, content);
-
-        match context {
-            CompletionContext::PackageName { prefix } => self.complete_package_names(&prefix).await,
-            CompletionContext::Version {
-                package_name,
-                prefix,
-            } => self.complete_versions(&package_name, &prefix).await,
-            CompletionContext::Feature { .. } | CompletionContext::None => vec![],
-        }
+        content: &'a str,
+    ) -> deps_core::ecosystem::BoxFuture<'a, Vec<CompletionItem>> {
+        Box::pin(async move {
+            use deps_core::completion::{CompletionContext, detect_completion_context};
+
+            let context = detect_completion_context(parse_result, position, content);
+
+            match context {
+                CompletionContext::PackageName { prefix } => {
+                    self.complete_package_names(&prefix).await
+                }
+                CompletionContext::Version {
+                    package_name,
+                    prefix,
+                } => self.complete_versions(&package_name, &prefix).await,
+                CompletionContext::Feature { .. } | CompletionContext::None => vec![],
+            }
+        })
     }
 
     fn as_any(&self) -> &dyn Any {

crates/deps-bundler/src/lockfile.rs

@@ -2,7 +2,6 @@
 //!
 //! Parses Gemfile.lock files to extract resolved dependency versions.
 
-use async_trait::async_trait;
 use deps_core::error::{DepsError, Result};
 use deps_core::lockfile::{
     LockFileProvider, ResolvedPackage, ResolvedPackages, ResolvedSource,
@@ -36,23 +35,28 @@ enum Section {
     RubyVersion,
 }
 
-#[async_trait]
 impl LockFileProvider for GemfileLockParser {
     fn locate_lockfile(&self, manifest_uri: &Uri) -> Option<PathBuf> {
         locate_lockfile_for_manifest(manifest_uri, Self::LOCKFILE_NAMES)
     }
 
-    async fn parse_lockfile(&self, lockfile_path: &Path) -> Result<ResolvedPackages> {
-        tracing::debug!("Parsing Gemfile.lock: {}", lockfile_path.display());
-
-        let content = tokio::fs::read_to_string(lockfile_path)
-            .await
-            .map_err(|e| DepsError::ParseError {
-                file_type: format!("Gemfile.lock at {}", lockfile_path.display()),
-                source: Box::new(e),
-            })?;
-
-        parse_gemfile_lock(&content)
+    fn parse_lockfile<'a>(
+        &'a self,
+        lockfile_path: &'a Path,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<ResolvedPackages>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            tracing::debug!("Parsing Gemfile.lock: {}", lockfile_path.display());
+
+            let content = tokio::fs::read_to_string(lockfile_path)
+                .await
+                .map_err(|e| DepsError::ParseError {
+                    file_type: format!("Gemfile.lock at {}", lockfile_path.display()),
+                    source: Box::new(e),
+                })?;
+
+            parse_gemfile_lock(&content)
+        })
     }
 }
 

crates/deps-bundler/src/registry.rs

@@ -165,32 +165,7 @@ fn parse_gem_info(data: &[u8]) -> Result<GemInfo> {
     })
 }
 
-// Implement PackageRegistry trait
-#[async_trait::async_trait]
-impl deps_core::PackageRegistry for RubyGemsRegistry {
-    type Version = BundlerVersion;
-    type Metadata = GemInfo;
-    type VersionReq = String;
-
-    async fn get_versions(&self, name: &str) -> Result<Vec<Self::Version>> {
-        self.get_versions(name).await
-    }
-
-    async fn get_latest_matching(
-        &self,
-        name: &str,
-        req: &Self::VersionReq,
-    ) -> Result<Option<Self::Version>> {
-        self.get_latest_matching(name, req).await
-    }
-
-    async fn search(&self, query: &str, limit: usize) -> Result<Vec<Self::Metadata>> {
-        self.search(query, limit).await
-    }
-}
-
-// Implement VersionInfo trait
-impl deps_core::VersionInfo for BundlerVersion {
+impl deps_core::Version for BundlerVersion {
     fn version_string(&self) -> &str {
         &self.number
     }
@@ -199,13 +174,12 @@ impl deps_core::VersionInfo for BundlerVersion {
         self.yanked
     }
 
-    fn features(&self) -> Vec<String> {
-        vec![]
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
     }
 }
 
-// Implement PackageMetadata trait
-impl deps_core::PackageMetadata for GemInfo {
+impl deps_core::Metadata for GemInfo {
     fn name(&self) -> &str {
         &self.name
     }
@@ -225,34 +199,50 @@ impl deps_core::PackageMetadata for GemInfo {
     fn latest_version(&self) -> &str {
         &self.version
     }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
 }
 
 // Implement Registry trait for trait object support
-#[async_trait::async_trait]
 impl deps_core::Registry for RubyGemsRegistry {
-    async fn get_versions(&self, name: &str) -> Result<Vec<Box<dyn deps_core::Version>>> {
-        let versions = self.get_versions(name).await?;
-        Ok(versions
-            .into_iter()
-            .map(|v| Box::new(v) as Box<dyn deps_core::Version>)
-            .collect())
+    fn get_versions<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> deps_core::ecosystem::BoxFuture<'a, Result<Vec<Box<dyn deps_core::Version>>>> {
+        Box::pin(async move {
+            let versions = self.get_versions(name).await?;
+            Ok(versions
+                .into_iter()
+                .map(|v| Box::new(v) as Box<dyn deps_core::Version>)
+                .collect())
+        })
     }
 
-    async fn get_latest_matching(
-        &self,
-        name: &str,
-        req: &str,
-    ) -> Result<Option<Box<dyn deps_core::Version>>> {
-        let version = self.get_latest_matching(name, req).await?;
-        Ok(version.map(|v| Box::new(v) as Box<dyn deps_core::Version>))
+    fn get_latest_matching<'a>(
+        &'a self,
+        name: &'a str,
+        req: &'a str,
+    ) -> deps_core::ecosystem::BoxFuture<'a, Result<Option<Box<dyn deps_core::Version>>>> {
+        Box::pin(async move {
+            let version = self.get_latest_matching(name, req).await?;
+            Ok(version.map(|v| Box::new(v) as Box<dyn deps_core::Version>))
+        })
     }
 
-    async fn search(&self, query: &str, limit: usize) -> Result<Vec<Box<dyn deps_core::Metadata>>> {
-        let results = self.search(query, limit).await?;
-        Ok(results
-            .into_iter()
-            .map(|m| Box::new(m) as Box<dyn deps_core::Metadata>)
-            .collect())
+    fn search<'a>(
+        &'a self,
+        query: &'a str,
+        limit: usize,
+    ) -> deps_core::ecosystem::BoxFuture<'a, Result<Vec<Box<dyn deps_core::Metadata>>>> {
+        Box::pin(async move {
+            let results = self.search(query, limit).await?;
+            Ok(results
+                .into_iter()
+                .map(|m| Box::new(m) as Box<dyn deps_core::Metadata>)
+                .collect())
+        })
     }
 
     fn package_url(&self, name: &str) -> String {
@@ -471,8 +461,8 @@ mod tests {
     }
 
     #[test]
-    fn test_version_info_trait() {
-        use deps_core::VersionInfo;
+    fn test_version_trait() {
+        use deps_core::Version;
 
         let version = BundlerVersion {
             number: "1.0.0".into(),
@@ -488,8 +478,8 @@ mod tests {
     }
 
     #[test]
-    fn test_package_metadata_trait() {
-        use deps_core::PackageMetadata;
+    fn test_metadata_trait() {
+        use deps_core::Metadata;
 
         let gem = GemInfo {
             name: "test".into(),
@@ -511,8 +501,8 @@ mod tests {
     }
 
     #[test]
-    fn test_package_metadata_trait_empty_optionals() {
-        use deps_core::PackageMetadata;
+    fn test_metadata_trait_empty_optionals() {
+        use deps_core::Metadata;
 
         let gem = GemInfo {
             name: "empty".into(),