refactor(rust): remove unused variable warnings and improve code quality

zTgx · zTgx · commit b1345d63e84d · 2026-04-15T09:44:52.000+08:00
- Replace unused variables with underscore prefix to eliminate compiler
  warnings across multiple modules including workspace.rs, emitter.rs,
  executor.rs, aggregator.rs, llm_pilot.rs, reference.rs, retriever.rs,
  beam.rs, evaluate.rs, hybrid.rs, and threshold.rs

- Remove overly permissive clippy allowances in lib.rs and replace with
  specific lint configurations for better code quality

- Add SearchAlgorithm and QueryComplexity exports to main library
 interface

- Include ReasoningIndexConfig in document type exports

- These changes clean up code by addressing unused variable warnings
  while maintaining all existing functionality
diff --git a/rust/src/client/workspace.rs b/rust/src/client/workspace.rs
@@ -135,7 +135,7 @@ impl WorkspaceClient {
         let doc = self.workspace.load_and_cache(doc_id).await?;
         let cache_hit = doc.is_some();
 
-        if let Some(ref doc) = doc {
+        if let Some(ref _doc) = doc {
             debug!("Loaded document: {} (cache={})", doc_id, cache_hit);
         }
 
diff --git a/rust/src/events/emitter.rs b/rust/src/events/emitter.rs
@@ -135,7 +135,7 @@ impl EventEmitter {
         for handler in &inner.index_handlers {
             handler(&event);
         }
-        for handler in &inner.async_handlers {
+        for _handler in &inner.async_handlers {
             // For sync context, we just log async handlers
             let event = Event::Index(event.clone());
             info!("Async event: {:?}", event);
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
@@ -3,10 +3,7 @@
 
 //! # Vectorless
 
-// Clippy: allow some pedantic lints that are too noisy for early-stage project
-#![allow(clippy::all)]
-#![allow(dead_code)]
-#![allow(unused_variables)]
+// Clippy: allow specific lints that are too noisy for this project
 #![allow(clippy::iter_over_hash_type)]
 #![allow(clippy::large_enum_variant)]
 #![allow(clippy::manual_unwrap_or_default)]
@@ -69,14 +66,16 @@ pub use client::{
 
 // Retrieval types
 pub use retrieval::StrategyPreference;
+pub use retrieval::pipeline::SearchAlgorithm;
+pub use retrieval::QueryComplexity;
 
 // Error types
 pub use error::{Error, Result};
 
 // Document types
 pub use document::{
-    DocumentStructure, DocumentTree, NodeId, StructureNode, TocConfig, TocEntry, TocNode, TocView,
-    TreeNode,
+    DocumentStructure, DocumentTree, NodeId, ReasoningIndexConfig, StructureNode, TocConfig,
+    TocEntry, TocNode, TocView, TreeNode,
 };
 
 // Graph types
diff --git a/rust/src/llm/executor.rs b/rust/src/llm/executor.rs
@@ -353,7 +353,7 @@ impl LlmExecutor {
         let truncated = self.truncate_prompt(user);
 
         // Build request based on whether max_tokens is specified
-        let request = if let Some(tokens) = max_tokens {
+        let request = if let Some(_tokens) = max_tokens {
             CreateChatCompletionRequestArgs::default()
                 .model(model)
                 .messages([
diff --git a/rust/src/retrieval/content/aggregator.rs b/rust/src/retrieval/content/aggregator.rs
@@ -104,7 +104,7 @@ impl ContentAggregator {
         tree: &DocumentTree,
         query: &str,
     ) -> AggregationResult {
-        let start = std::time::Instant::now();
+        let _start = std::time::Instant::now();
 
         // Step 1: Collect all content chunks from candidates and their descendants
         let chunks = self.collect_chunks(candidates, tree);
diff --git a/rust/src/retrieval/pilot/llm_pilot.rs b/rust/src/retrieval/pilot/llm_pilot.rs
@@ -269,9 +269,9 @@ impl LlmPilot {
     fn compute_cache_key(
         &self,
         context: &super::builder::PilotContext,
-        point: InterventionPoint,
+        _point: InterventionPoint,
     ) -> Option<MemoKey> {
-        let store = self.memo_store.as_ref()?;
+        let _store = self.memo_store.as_ref()?;
 
         // Build a fingerprint from the context using available methods
         let context_str = context.to_string();
diff --git a/rust/src/retrieval/reference.rs b/rust/src/retrieval/reference.rs
@@ -220,7 +220,7 @@ impl ReferenceFollower {
         };
 
         // Use pre-extracted references if available, otherwise extract
-        let refs = if !node.references.is_empty() {
+        let _refs = if !node.references.is_empty() {
             node.references.clone()
         } else {
             ReferenceExtractor::extract(&node.content)
@@ -325,7 +325,7 @@ impl ReferenceFollower {
 
             // Get references from this node
             if let Some(node) = tree.get(node_id) {
-                let refs = if !node.references.is_empty() {
+                let _refs = if !node.references.is_empty() {
                     node.references.clone()
                 } else {
                     ReferenceExtractor::extract(&node.content)
diff --git a/rust/src/retrieval/retriever.rs b/rust/src/retrieval/retriever.rs
@@ -81,7 +81,7 @@ pub trait Retriever: Send + Sync {
     ///
     /// Returns an estimated number of LLM calls or tokens that will be used.
     /// Useful for cost-aware strategy selection.
-    fn estimate_cost(&self, tree: &DocumentTree, options: &RetrieveOptions) -> CostEstimate {
+    fn estimate_cost(&self, tree: &DocumentTree, _options: &RetrieveOptions) -> CostEstimate {
         let node_count = tree.node_count();
         CostEstimate {
             llm_calls: node_count / 2, // Rough estimate
diff --git a/rust/src/retrieval/search/beam.rs b/rust/src/retrieval/search/beam.rs
@@ -134,7 +134,7 @@ impl BeamSearch {
         tree: &DocumentTree,
         context: &RetrievalContext,
         pilot: Option<&dyn Pilot>,
-        cache: &PilotDecisionCache,
+        _cache: &PilotDecisionCache,
         visited: &HashSet<NodeId>,
         fallback_stack: &mut Vec<FallbackEntry>,
         result: &mut SearchResult,
diff --git a/rust/src/retrieval/stages/evaluate.rs b/rust/src/retrieval/stages/evaluate.rs
@@ -410,7 +410,7 @@ impl RetrievalStage for EvaluateStage {
             let doc_key = format!("{:?}", ctx.tree.root());
             for candidate in ctx.candidates.iter().take(3) {
                 if let Some(node) = ctx.tree.get(candidate.node_id) {
-                    let path = format!("{}", node.depth);
+                    let _path = format!("{}", node.depth);
                     // Use the node title as path identifier for L2
                     ctx.reasoning_cache
                         .l2_record(&doc_key, &node.title, candidate.score);
diff --git a/rust/src/retrieval/strategy/hybrid.rs b/rust/src/retrieval/strategy/hybrid.rs
@@ -353,7 +353,7 @@ impl RetrievalStrategy for HybridStrategy {
 
             // Map LLM results back with combined scores
             let mut llm_iter = llm_results.into_iter();
-            for (idx, node_id, bm25_score) in &needs_llm {
+            for (idx, _node_id, bm25_score) in &needs_llm {
                 if candidate_indices.contains(idx) {
                     if let Some(llm_eval) = llm_iter.next() {
                         let combined_score = self.combine_scores(*bm25_score, llm_eval.score);
diff --git a/rust/src/retrieval/sufficiency/threshold.rs b/rust/src/retrieval/sufficiency/threshold.rs
@@ -104,7 +104,7 @@ impl Default for ThresholdChecker {
 }
 
 impl SufficiencyChecker for ThresholdChecker {
-    fn check(&self, query: &str, content: &str, token_count: usize) -> SufficiencyLevel {
+    fn check(&self, _query: &str, content: &str, token_count: usize) -> SufficiencyLevel {
         let estimated_tokens = if token_count == 0 {
             self.estimate_tokens(content)
         } else {

Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ impl WorkspaceClient {`
`135`	`135`	`let doc = self.workspace.load_and_cache(doc_id).await?;`
`136`	`136`	`let cache_hit = doc.is_some();`
`137`	`137`
`138`		`- if let Some(ref doc) = doc {`
	`138`	`+ if let Some(ref _doc) = doc {`
`139`	`139`	`debug!("Loaded document: {} (cache={})", doc_id, cache_hit);`
`140`	`140`	`}`
`141`	`141`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ impl EventEmitter {`
`135`	`135`	`for handler in &inner.index_handlers {`
`136`	`136`	`handler(&event);`
`137`	`137`	`}`
`138`		`- for handler in &inner.async_handlers {`
	`138`	`+ for _handler in &inner.async_handlers {`
`139`	`139`	`// For sync context, we just log async handlers`
`140`	`140`	`let event = Event::Index(event.clone());`
`141`	`141`	`info!("Async event: {:?}", event);`