Struct GenericCompletionEngine 

pub struct GenericCompletionEngine { /* private fields */ }

Generic completion engine implementation

This is the main implementation of the completion engine. It coordinates external LSP routing, context analysis, completion generation, and ranking to produce ranked completion suggestions.

Completion Flow

The engine follows this flow for each completion request:

1. External LSP Check: Check if an external LSP server is configured for the language
2. Context Analysis: Analyze code context to determine available symbols and expected types
3. Completion Generation: Generate suggestions using:
   • External LSP server (if available and configured)
   • Language-specific provider (if registered)
   • Generic completion generator (fallback)
4. Merging: Merge external and internal completions (external takes priority)
5. Ranking: Rank all completions by relevance, frequency, and recency

Language Support

The engine supports multiple languages through a pluggable provider system:

• If an external LSP server is configured, it will be used for semantic completions
• If a language-specific provider is registered, it will be used as fallback
• Otherwise, the generic completion generator is used as a fallback

Graceful Degradation

If the external LSP server is unavailable or times out:

• The system falls back to language-specific providers
• If no provider is available, the generic generator is used
• Users always get some completions, even if not semantic

Example

use ricecoder_completion::engine::*;
use ricecoder_completion::types::*;
use std::sync::Arc;

let engine = GenericCompletionEngine::new(
    Arc::new(GenericContextAnalyzer),
    Arc::new(BasicCompletionGenerator),
    Arc::new(BasicCompletionRanker::default_weights()),
    ProviderRegistry::new(),
);

Implementations

impl GenericCompletionEngine

pub fn new( context_analyzer: Arc<dyn ContextAnalyzer>, generator: Arc<dyn CompletionGenerator>, ranker: Arc<dyn CompletionRanker>, provider_registry: ProviderRegistry, ) -> Self

Create a new completion engine

Arguments

• context_analyzer - Analyzer for determining code context
• generator - Generic completion generator (used as fallback)
• ranker - Ranker for sorting completions
• provider_registry - Registry of language-specific providers

Trait Implementations

impl CompletionEngine for GenericCompletionEngine

fn generate_completions<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, code: &'life1 str, position: Position, language: &'life2 str, ) -> Pin<Box<dyn Future<Output = CompletionResult<Vec<CompletionItem>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Generate completion suggestions for the given code at the specified position

fn resolve_completion<'life0, 'life1, 'async_trait>( &'life0 self, item: &'life1 CompletionItem, ) -> Pin<Box<dyn Future<Output = CompletionResult<CompletionItem>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Resolve additional details for a completion item