Struct CompletionContext 

pub(crate) struct CompletionContext<'a> {

    pub(crate) sema: Semantics<'a, RootDatabase>,
    pub(crate) scope: SemanticsScope<'a>,
    pub(crate) db: &'a RootDatabase,
    pub(crate) config: &'a CompletionConfig<'a>,
    pub(crate) position: FilePosition,
    pub(crate) trigger_character: Option<char>,
    pub(crate) original_token: SyntaxToken,
    pub(crate) token: SyntaxToken,
    pub(crate) krate: Crate,
    pub(crate) display_target: DisplayTarget,
    pub(crate) module: Module,
    pub(crate) containing_function: Option<Function>,
    pub(crate) is_nightly: bool,
    pub(crate) edition: Edition,
    pub(crate) expected_name: Option<NameOrNameRef>,
    pub(crate) expected_type: Option<Type<'a>>,
    pub(crate) qualifier_ctx: QualifierCtx,
    pub(crate) locals: FxHashMap<Name, Local>,
    pub(crate) depth_from_crate_root: usize,
    pub(crate) exclude_flyimport: FxHashMap<ModuleDef, AutoImportExclusionType>,
    pub(crate) exclude_traits: FxHashSet<Trait>,
    pub(crate) complete_semicolon: CompleteSemicolon,
}

CompletionContext is created early during completion to figure out, where exactly is the cursor, syntax-wise.

Fields

sema: Semantics<'a, RootDatabase>

scope: SemanticsScope<'a>

db: &'a RootDatabase

config: &'a CompletionConfig<'a>

position: FilePosition

trigger_character: Option<char>

original_token: SyntaxToken

The token before the cursor, in the original file.

token: SyntaxToken

The token before the cursor, in the macro-expanded file.

krate: Crate

The crate of the current file.

display_target: DisplayTarget

module: Module

The module of the scope.

containing_function: Option<Function>

The function where we’re completing, if inside a function.

is_nightly: bool

Whether nightly toolchain is used. Cached since this is looked up a lot.

edition: Edition

The edition of the current crate

expected_name: Option<NameOrNameRef>

The expected name of what we are completing. This is usually the parameter name of the function argument we are completing.

expected_type: Option<Type<'a>>

The expected type of what we are completing.

qualifier_ctx: QualifierCtx

locals: FxHashMap<Name, Local>

depth_from_crate_root: usize

The module depth of the current module of the cursor position.

• crate-root
• mod foo
• mod bar

Here depth will be 2

exclude_flyimport: FxHashMap<ModuleDef, AutoImportExclusionType>

Traits whose methods will be excluded from flyimport. Flyimport should not suggest importing those traits.

Note the trait themselves are not excluded, only their methods are.

exclude_traits: FxHashSet<Trait>

Traits whose methods should always be excluded, even when in scope (compare exclude_flyimport_traits). They will not be excluded, however, if they are available as a generic bound.

Note the trait themselves are not excluded, only their methods are.

complete_semicolon: CompleteSemicolon

Whether and how to complete semicolon for unit-returning functions.

Implementations

impl CompletionContext<'_>

pub(crate) fn source_range(&self) -> TextRange

The range of the identifier that is being completed.

pub(crate) fn famous_defs(&self) -> FamousDefs<'_, '_>

pub(crate) fn def_is_visible(&self, item: &ScopeDef) -> Visible

Checks if an item is visible and not doc(hidden) at the completion site.

pub(crate) fn is_visible<I>(&self, item: &I) -> Visible

where I: HasVisibility + HasAttrs + HasCrate + Copy,

Checks if an item is visible, not doc(hidden) and stable at the completion site.

pub(crate) fn doc_aliases<I>(&self, item: &I) -> Vec<SmolStr>

where I: HasAttrs + Copy,

pub(crate) fn is_item_hidden(&self, item: &ItemInNs) -> bool

Check if an item is #[doc(hidden)].

pub(crate) fn check_stability(&self, attrs: Option<&AttrsWithOwner>) -> bool

Checks whether this item should be listed in regards to stability. Returns true if we should.

pub(crate) fn check_stability_and_hidden<I>(&self, item: I) -> bool

where I: HasAttrs + HasCrate,

pub(crate) fn is_ops_trait(&self, trait_: Trait) -> bool

Whether the given trait is an operator trait or not.

pub(crate) fn is_doc_notable_trait(&self, trait_: Trait) -> bool

Whether the given trait has #[doc(notable_trait)]

pub(crate) fn traits_in_scope(&self) -> VisibleTraits

Returns the traits in scope, with the Drop trait removed.

pub(crate) fn iterate_path_candidates( &self, ty: &Type<'_>, cb: impl FnMut(AssocItem), )

pub(crate) fn process_all_names( &self, f: &mut dyn FnMut(Name, ScopeDef, Vec<SmolStr>), )

A version of [SemanticsScope::process_all_names] that filters out #[doc(hidden)] items and passes all doc-aliases along, to funnel it into Completions::add_path_resolution.

pub(crate) fn process_all_names_raw(&self, f: &mut dyn FnMut(Name, ScopeDef))

fn is_scope_def_hidden(&self, scope_def: ScopeDef) -> bool

fn is_visible_impl( &self, vis: &Visibility, attrs: &AttrsWithOwner, defining_crate: Crate, ) -> Visible

pub(crate) fn is_doc_hidden( &self, attrs: &AttrsWithOwner, defining_crate: Crate, ) -> bool

pub(crate) fn doc_aliases_in_scope(&self, scope_def: ScopeDef) -> Vec<SmolStr>

impl<'db> CompletionContext<'db>

pub(crate) fn new( db: &'db RootDatabase, position: FilePosition, config: &'db CompletionConfig<'db>, trigger_character: Option<char>, ) -> Option<(CompletionContext<'db>, CompletionAnalysis<'db>)>

Trait Implementations

impl<'a> Debug for CompletionContext<'a>

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

Formats the value using the given formatter.