Enum CompletionContext 

pub enum CompletionContext {
    General,
    PropertyAccess {
        object: String,
    },
    FunctionCall {
        function: String,
        arg_context: ArgumentContext,
    },
    PatternBody,
    Query {
        query_type: String,
    },
    PatternReference,
    TypeAnnotation,
    Annotation,
    AnnotationArgs {
        annotation: String,
    },
    ImportModule,
    FromModule,
    FromModulePartial {
        prefix: String,
    },
    ImportItems {
        module: String,
    },
    PipeTarget {
        pipe_input_type: Option<String>,
    },
    ImplBlock {
        trait_name: String,
        target_type: String,
        existing_methods: Vec<String>,
    },
    TypeAliasOverride {
        base_type: String,
    },
    JoinStrategy,
    JoinBody {
        strategy: String,
    },
    TraitBound,
    ComptimeBlock,
    ExprAnnotation,
    DocTag {
        prefix: String,
    },
    DocParamName {
        prefix: String,
    },
    DocTypeParamName {
        prefix: String,
    },
    DocLinkTarget {
        prefix: String,
    },
    InterpolationFormatSpec {
        spec_prefix: String,
    },
}

Completion context based on cursor position

Variants

General

General context - show all completions

PropertyAccess

After a dot operator - show properties/methods

Fields

object: String

The expression before the dot

FunctionCall

Inside a function call - show parameters

Fields

function: String

The function being called

arg_context: ArgumentContext

Detailed argument context

PatternBody

Inside a pattern definition

Query

Inside a query (find, scan, etc.)

Fields

query_type: String

The type of query (find, scan, analyze, backtest, alert)

PatternReference

After “pattern” keyword - suggest pattern names

TypeAnnotation

Type annotation context

Annotation

After typing “@” at function/pattern start

AnnotationArgs

Inside annotation arguments @foo(|)

Fields

annotation: String

The annotation being used

ImportModule

After “use “ — suggest extension modules for namespace import

FromModule

After “from “ — suggest importable modules for named import

FromModulePartial

After “from .” — suggest next namespace segments

Fields

prefix: String

The prefix typed so far (e.g., “std.core”, “mydep”)

ImportItems

Inside “from use { “ — suggest module exports

Fields

module: String

The module being imported from

PipeTarget

After pipe operator |> — suggest functions/methods that accept the piped type

Fields

pipe_input_type: Option<String>

The inferred type of the expression before |>

ImplBlock

Inside an impl block body — suggest unimplemented trait methods

Fields

trait_name: String

The trait name being implemented

target_type: String

The target type implementing the trait

existing_methods: Vec<String>

Methods already implemented in self impl block

TypeAliasOverride

Inside a type alias override: type EUR = Currency { | } Suggests comptime field names from the base type

Fields

base_type: String

The base type being aliased (e.g., “Currency”)

JoinStrategy

After await join — suggest join strategies (all, race, any, settle)

JoinBody

Inside a join block body — suggest labeled branch snippets

Fields

strategy: String

The join strategy (all, race, any, settle)

TraitBound

In a trait bound position: fn foo<T: |> — suggest trait names

ComptimeBlock

Inside a comptime { } block — suggest comptime builtins + normal expressions

ExprAnnotation

After @ in expression position — suggest annotations for expression-level decoration

DocTag

After @ inside a /// doc comment.

Fields

prefix: String

The partial tag name typed so far.

DocParamName

In a @param doc tag.

Fields

prefix: String

The partial parameter name typed so far.

DocTypeParamName

In a @typeparam doc tag.

Fields

prefix: String

The partial type parameter name typed so far.

DocLinkTarget

In a @see or @link doc tag target.

Fields

prefix: String

The partial fully qualified symbol typed so far.

InterpolationFormatSpec

Inside formatted interpolation spec after expr: in f"{expr:...}".

Fields

spec_prefix: String

The currently typed prefix after :.

Trait Implementations

impl Clone for CompletionContext

fn clone(&self) -> CompletionContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompletionContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CompletionContext

fn eq(&self, other: &CompletionContext) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CompletionContext