ide_completion/
context.rs

1//! See [`CompletionContext`] structure.
2
3mod analysis;
4#[cfg(test)]
5mod tests;
6
7use std::{iter, sync::LazyLock};
8
9use base_db::toolchain_channel;
10use hir::{
11    DisplayTarget, HasAttrs, InFile, Local, ModuleDef, ModuleSource, Name, PathResolution,
12    ScopeDef, Semantics, SemanticsScope, Symbol, Type, TypeInfo, sym,
13};
14use ide_db::{
15    FilePosition, FxHashMap, FxHashSet, RootDatabase, famous_defs::FamousDefs,
16    helpers::is_editable_crate, syntax_helpers::node_ext::is_in_macro_matcher,
17};
18use itertools::Either;
19use syntax::{
20    AstNode, Edition, SmolStr,
21    SyntaxKind::{self, *},
22    SyntaxToken, T, TextRange, TextSize,
23    ast::{self, AttrKind, NameOrNameRef},
24};
25
26use crate::{
27    CompletionConfig,
28    config::AutoImportExclusionType,
29    context::analysis::{AnalysisResult, expand_and_analyze},
30};
31
32const COMPLETION_MARKER: &str = "raCompletionMarker";
33
34#[derive(Copy, Clone, Debug, PartialEq, Eq)]
35pub(crate) enum PatternRefutability {
36    Refutable,
37    Irrefutable,
38}
39
40#[derive(Debug)]
41pub(crate) enum Visible {
42    Yes,
43    Editable,
44    No,
45}
46
47/// Existing qualifiers for the thing we are currently completing.
48#[derive(Debug, Default)]
49pub(crate) struct QualifierCtx {
50    // TODO: Add try_tok and default_tok
51    pub(crate) async_tok: Option<SyntaxToken>,
52    pub(crate) unsafe_tok: Option<SyntaxToken>,
53    pub(crate) safe_tok: Option<SyntaxToken>,
54    pub(crate) vis_node: Option<ast::Visibility>,
55    pub(crate) abi_node: Option<ast::Abi>,
56}
57
58impl QualifierCtx {
59    pub(crate) fn none(&self) -> bool {
60        self.async_tok.is_none()
61            && self.unsafe_tok.is_none()
62            && self.safe_tok.is_none()
63            && self.vis_node.is_none()
64            && self.abi_node.is_none()
65    }
66}
67
68/// The state of the path we are currently completing.
69#[derive(Debug)]
70pub(crate) struct PathCompletionCtx<'db> {
71    /// If this is a call with () already there (or {} in case of record patterns)
72    pub(crate) has_call_parens: bool,
73    /// If this has a macro call bang !
74    pub(crate) has_macro_bang: bool,
75    /// The qualifier of the current path.
76    pub(crate) qualified: Qualified<'db>,
77    /// The parent of the path we are completing.
78    pub(crate) parent: Option<ast::Path>,
79    #[allow(dead_code)]
80    /// The path of which we are completing the segment
81    pub(crate) path: ast::Path,
82    /// The path of which we are completing the segment in the original file
83    pub(crate) original_path: Option<ast::Path>,
84    pub(crate) kind: PathKind<'db>,
85    /// Whether the path segment has type args or not.
86    pub(crate) has_type_args: bool,
87    /// Whether the qualifier comes from a use tree parent or not
88    pub(crate) use_tree_parent: bool,
89}
90
91impl PathCompletionCtx<'_> {
92    pub(crate) fn is_trivial_path(&self) -> bool {
93        matches!(
94            self,
95            PathCompletionCtx {
96                has_call_parens: false,
97                has_macro_bang: false,
98                qualified: Qualified::No,
99                parent: None,
100                has_type_args: false,
101                ..
102            }
103        )
104    }
105
106    pub(crate) fn required_thin_arrow(&self) -> Option<(&'static str, TextSize)> {
107        let PathKind::Type {
108            location:
109                TypeLocation::TypeAscription(TypeAscriptionTarget::RetType {
110                    item: Some(ref fn_item),
111                    ..
112                }),
113        } = self.kind
114        else {
115            return None;
116        };
117        if fn_item.ret_type().is_some_and(|it| it.thin_arrow_token().is_some()) {
118            return None;
119        }
120        let ret_type = fn_item.ret_type().and_then(|it| it.ty());
121        match (ret_type, fn_item.param_list()) {
122            (Some(ty), _) => Some(("-> ", ty.syntax().text_range().start())),
123            (None, Some(param)) => Some((" ->", param.syntax().text_range().end())),
124            (None, None) => None,
125        }
126    }
127}
128
129/// The kind of path we are completing right now.
130#[derive(Debug, PartialEq, Eq)]
131pub(crate) enum PathKind<'db> {
132    Expr {
133        expr_ctx: PathExprCtx<'db>,
134    },
135    Type {
136        location: TypeLocation,
137    },
138    Attr {
139        attr_ctx: AttrCtx,
140    },
141    Derive {
142        existing_derives: ExistingDerives,
143    },
144    /// Path in item position, that is inside an (Assoc)ItemList
145    Item {
146        kind: ItemListKind,
147    },
148    Pat {
149        pat_ctx: PatternContext,
150    },
151    Vis {
152        has_in_token: bool,
153    },
154    Use,
155}
156
157pub(crate) type ExistingDerives = FxHashSet<hir::Macro>;
158
159#[derive(Debug, PartialEq, Eq)]
160pub(crate) struct AttrCtx {
161    pub(crate) kind: AttrKind,
162    pub(crate) annotated_item_kind: Option<SyntaxKind>,
163    pub(crate) derive_helpers: Vec<(Symbol, Symbol)>,
164}
165
166#[derive(Debug, PartialEq, Eq)]
167pub(crate) struct PathExprCtx<'db> {
168    pub(crate) in_block_expr: bool,
169    pub(crate) in_breakable: Option<BreakableKind>,
170    pub(crate) after_if_expr: bool,
171    pub(crate) before_else_kw: bool,
172    /// Whether this expression is the direct condition of an if or while expression
173    pub(crate) in_condition: bool,
174    pub(crate) incomplete_let: bool,
175    pub(crate) after_incomplete_let: bool,
176    pub(crate) in_value: bool,
177    pub(crate) ref_expr_parent: Option<ast::RefExpr>,
178    pub(crate) after_amp: bool,
179    /// The surrounding RecordExpression we are completing a functional update
180    pub(crate) is_func_update: Option<ast::RecordExpr>,
181    pub(crate) self_param: Option<Either<hir::SelfParam, hir::Param<'db>>>,
182    pub(crate) innermost_ret_ty: Option<hir::Type<'db>>,
183    pub(crate) innermost_breakable_ty: Option<hir::Type<'db>>,
184    pub(crate) impl_: Option<ast::Impl>,
185    /// Whether this expression occurs in match arm guard position: before the
186    /// fat arrow token
187    pub(crate) in_match_guard: bool,
188}
189
190/// Original file ast nodes
191#[derive(Clone, Debug, PartialEq, Eq)]
192pub(crate) enum TypeLocation {
193    TupleField,
194    TypeAscription(TypeAscriptionTarget),
195    /// Generic argument position e.g. `Foo<$0>`
196    GenericArg {
197        /// The generic argument list containing the generic arg
198        args: Option<ast::GenericArgList>,
199        /// `Some(trait_)` if `trait_` is being instantiated with `args`
200        of_trait: Option<hir::Trait>,
201        /// The generic parameter being filled in by the generic arg
202        corresponding_param: Option<ast::GenericParam>,
203    },
204    /// Associated type equality constraint e.g. `Foo<Bar = $0>`
205    AssocTypeEq,
206    /// Associated constant equality constraint e.g. `Foo<X = $0>`
207    AssocConstEq,
208    TypeBound,
209    ImplTarget,
210    ImplTrait,
211    Other,
212}
213
214impl TypeLocation {
215    pub(crate) fn complete_lifetimes(&self) -> bool {
216        matches!(
217            self,
218            TypeLocation::GenericArg {
219                corresponding_param: Some(ast::GenericParam::LifetimeParam(_)),
220                ..
221            }
222        )
223    }
224
225    pub(crate) fn complete_consts(&self) -> bool {
226        matches!(
227            self,
228            TypeLocation::GenericArg {
229                corresponding_param: Some(ast::GenericParam::ConstParam(_)),
230                ..
231            } | TypeLocation::AssocConstEq
232        )
233    }
234
235    pub(crate) fn complete_types(&self) -> bool {
236        match self {
237            TypeLocation::GenericArg { corresponding_param: Some(param), .. } => {
238                matches!(param, ast::GenericParam::TypeParam(_))
239            }
240            TypeLocation::AssocConstEq => false,
241            TypeLocation::AssocTypeEq => true,
242            TypeLocation::ImplTrait => false,
243            _ => true,
244        }
245    }
246
247    pub(crate) fn complete_self_type(&self) -> bool {
248        self.complete_types() && !matches!(self, TypeLocation::ImplTarget | TypeLocation::ImplTrait)
249    }
250}
251
252#[derive(Clone, Debug, PartialEq, Eq)]
253pub(crate) enum TypeAscriptionTarget {
254    Let(Option<ast::Pat>),
255    FnParam(Option<ast::Pat>),
256    RetType { body: Option<ast::Expr>, item: Option<ast::Fn> },
257    Const(Option<ast::Expr>),
258}
259
260/// The kind of item list a [`PathKind::Item`] belongs to.
261#[derive(Debug, PartialEq, Eq)]
262pub(crate) enum ItemListKind {
263    SourceFile,
264    Module,
265    Impl,
266    TraitImpl(Option<ast::Impl>),
267    Trait,
268    ExternBlock { is_unsafe: bool },
269}
270
271#[derive(Debug)]
272pub(crate) enum Qualified<'db> {
273    No,
274    With {
275        path: ast::Path,
276        resolution: Option<PathResolution>,
277        /// How many `super` segments are present in the path
278        ///
279        /// This would be None, if path is not solely made of
280        /// `super` segments, e.g.
281        ///
282        /// ```ignore
283        /// use super::foo;
284        /// ```
285        ///
286        /// Otherwise it should be Some(count of `super`)
287        super_chain_len: Option<usize>,
288    },
289    /// <_>::
290    TypeAnchor {
291        ty: Option<hir::Type<'db>>,
292        trait_: Option<hir::Trait>,
293    },
294    /// Whether the path is an absolute path
295    Absolute,
296}
297
298/// The state of the pattern we are completing.
299#[derive(Debug, Clone, PartialEq, Eq)]
300pub(crate) struct PatternContext {
301    pub(crate) refutability: PatternRefutability,
302    pub(crate) param_ctx: Option<ParamContext>,
303    pub(crate) has_type_ascription: bool,
304    pub(crate) should_suggest_name: bool,
305    pub(crate) after_if_expr: bool,
306    pub(crate) parent_pat: Option<ast::Pat>,
307    pub(crate) ref_token: Option<SyntaxToken>,
308    pub(crate) mut_token: Option<SyntaxToken>,
309    /// The record pattern this name or ref is a field of
310    pub(crate) record_pat: Option<ast::RecordPat>,
311    pub(crate) impl_or_trait: Option<Either<ast::Impl, ast::Trait>>,
312    /// List of missing variants in a match expr
313    pub(crate) missing_variants: Vec<hir::EnumVariant>,
314}
315
316#[derive(Debug, Clone, PartialEq, Eq)]
317pub(crate) struct ParamContext {
318    pub(crate) param_list: ast::ParamList,
319    pub(crate) param: ast::Param,
320    pub(crate) kind: ParamKind,
321}
322
323/// The state of the lifetime we are completing.
324#[derive(Debug)]
325pub(crate) struct LifetimeContext {
326    pub(crate) kind: LifetimeKind,
327}
328
329/// The kind of lifetime we are completing.
330#[derive(Debug)]
331pub(crate) enum LifetimeKind {
332    LifetimeParam,
333    Lifetime { in_lifetime_param_bound: bool, def: Option<hir::GenericDef> },
334    LabelRef,
335    LabelDef,
336}
337
338/// The state of the name we are completing.
339#[derive(Debug)]
340pub(crate) struct NameContext {
341    #[allow(dead_code)]
342    pub(crate) name: Option<ast::Name>,
343    pub(crate) kind: NameKind,
344}
345
346/// The kind of the name we are completing.
347#[derive(Debug)]
348#[allow(dead_code)]
349pub(crate) enum NameKind {
350    Const,
351    ConstParam,
352    Enum,
353    Function,
354    IdentPat(PatternContext),
355    MacroDef,
356    MacroRules,
357    /// Fake node
358    Module(ast::Module),
359    RecordField,
360    Rename,
361    SelfParam,
362    Static,
363    Struct,
364    Trait,
365    TypeAlias,
366    TypeParam,
367    Union,
368    Variant,
369}
370
371/// The state of the NameRef we are completing.
372#[derive(Debug)]
373pub(crate) struct NameRefContext<'db> {
374    /// NameRef syntax in the original file
375    pub(crate) nameref: Option<ast::NameRef>,
376    pub(crate) kind: NameRefKind<'db>,
377}
378
379/// The kind of the NameRef we are completing.
380#[derive(Debug)]
381pub(crate) enum NameRefKind<'db> {
382    Path(PathCompletionCtx<'db>),
383    DotAccess(DotAccess<'db>),
384    /// Position where we are only interested in keyword completions
385    Keyword(ast::Item),
386    /// The record expression this nameref is a field of and whether a dot precedes the completion identifier.
387    RecordExpr {
388        dot_prefix: bool,
389        expr: ast::RecordExpr,
390    },
391    Pattern(PatternContext),
392    ExternCrate,
393}
394
395/// The identifier we are currently completing.
396#[derive(Debug)]
397pub(crate) enum CompletionAnalysis<'db> {
398    Name(NameContext),
399    NameRef(NameRefContext<'db>),
400    Lifetime(LifetimeContext),
401    /// The string the cursor is currently inside
402    String {
403        /// original token
404        original: ast::String,
405        /// fake token
406        expanded: Option<ast::String>,
407    },
408    /// Set if we are currently completing in an unexpanded attribute, this usually implies a builtin attribute like `allow($0)`
409    UnexpandedAttrTT {
410        colon_prefix: bool,
411        fake_attribute_under_caret: Option<ast::TokenTreeMeta>,
412        extern_crate: Option<ast::ExternCrate>,
413    },
414    /// Set if we are inside the predicate of a `#[cfg]` or `#[cfg_attr]`.
415    CfgPredicate,
416    MacroSegment,
417}
418
419/// Information about the field or method access we are completing.
420#[derive(Debug)]
421pub(crate) struct DotAccess<'db> {
422    pub(crate) receiver: Option<ast::Expr>,
423    pub(crate) receiver_ty: Option<TypeInfo<'db>>,
424    pub(crate) kind: DotAccessKind,
425    pub(crate) ctx: DotAccessExprCtx,
426}
427
428#[derive(Debug, Clone, Copy)]
429pub(crate) enum DotAccessKind {
430    Field {
431        /// True if the receiver is an integer and there is no ident in the original file after it yet
432        /// like `0.$0`
433        receiver_is_ambiguous_float_literal: bool,
434    },
435    Method,
436}
437
438#[derive(Debug, Clone, Copy, PartialEq, Eq)]
439pub(crate) struct DotAccessExprCtx {
440    pub(crate) in_block_expr: bool,
441    pub(crate) in_breakable: Option<BreakableKind>,
442}
443
444#[derive(Copy, Clone, Debug, PartialEq, Eq)]
445pub(crate) enum BreakableKind {
446    Loop,
447    For,
448    While,
449    Block,
450}
451
452#[derive(Clone, Debug, PartialEq, Eq)]
453pub(crate) enum ParamKind {
454    Function(ast::Fn),
455    Closure(ast::ClosureExpr),
456}
457
458/// `CompletionContext` is created early during completion to figure out, where
459/// exactly is the cursor, syntax-wise.
460#[derive(Debug)]
461pub(crate) struct CompletionContext<'a, 'db> {
462    pub(crate) sema: Semantics<'db, RootDatabase>,
463    pub(crate) scope: SemanticsScope<'db>,
464    pub(crate) db: &'db RootDatabase,
465    pub(crate) config: &'a CompletionConfig<'a>,
466    pub(crate) position: FilePosition,
467
468    pub(crate) trigger_character: Option<char>,
469    /// The token before the cursor, in the original file.
470    pub(crate) original_token: SyntaxToken,
471    /// The token before the cursor, in the macro-expanded file.
472    pub(crate) token: SyntaxToken,
473    /// The crate of the current file.
474    pub(crate) krate: hir::Crate,
475    pub(crate) display_target: DisplayTarget,
476    /// The module of the `scope`.
477    pub(crate) module: hir::Module,
478    /// The function where we're completing, if inside a function.
479    pub(crate) containing_function: Option<hir::Function>,
480    /// Whether nightly toolchain is used. Cached since this is looked up a lot.
481    pub(crate) is_nightly: bool,
482    /// The edition of the current crate
483    // FIXME: This should probably be the crate of the current token?
484    pub(crate) edition: Edition,
485
486    /// The expected name of what we are completing.
487    /// This is usually the parameter name of the function argument we are completing.
488    pub(crate) expected_name: Option<NameOrNameRef>,
489    /// The expected type of what we are completing.
490    pub(crate) expected_type: Option<Type<'db>>,
491
492    pub(crate) qualifier_ctx: QualifierCtx,
493
494    pub(crate) locals: FxHashMap<Name, Local>,
495
496    /// The module depth of the current module of the cursor position.
497    /// - crate-root
498    ///  - mod foo
499    ///   - mod bar
500    ///
501    /// Here depth will be 2
502    pub(crate) depth_from_crate_root: usize,
503
504    /// Traits whose methods will be excluded from flyimport. Flyimport should not suggest
505    /// importing those traits.
506    ///
507    /// Note the trait *themselves* are not excluded, only their methods are.
508    pub(crate) exclude_flyimport: FxHashMap<ModuleDef, AutoImportExclusionType>,
509    /// Traits whose methods should always be excluded, even when in scope (compare `exclude_flyimport_traits`).
510    /// They will *not* be excluded, however, if they are available as a generic bound.
511    ///
512    /// Note the trait *themselves* are not excluded, only their methods are.
513    pub(crate) exclude_traits: FxHashSet<hir::Trait>,
514
515    /// Whether and how to complete semicolon for unit-returning functions.
516    pub(crate) complete_semicolon: CompleteSemicolon,
517}
518
519#[derive(Debug)]
520pub(crate) enum CompleteSemicolon {
521    DoNotComplete,
522    CompleteSemi,
523    CompleteComma,
524}
525
526impl<'db> CompletionContext<'_, 'db> {
527    /// The range of the identifier that is being completed.
528    pub(crate) fn source_range(&self) -> TextRange {
529        let kind = self.original_token.kind();
530        match kind {
531            CHAR => {
532                // assume we are completing a lifetime but the user has only typed the '
533                cov_mark::hit!(completes_if_lifetime_without_idents);
534                TextRange::at(self.original_token.text_range().start(), TextSize::from(1))
535            }
536            LIFETIME_IDENT | UNDERSCORE | INT_NUMBER => self.original_token.text_range(),
537            // We want to consider all keywords in all editions.
538            _ if kind.is_any_identifier() => self.original_token.text_range(),
539            _ => TextRange::empty(self.position.offset),
540        }
541    }
542
543    pub(crate) fn famous_defs(&self) -> FamousDefs<'_, 'db> {
544        FamousDefs(&self.sema, self.krate)
545    }
546
547    /// Checks if an item is visible and not `doc(hidden)` at the completion site.
548    pub(crate) fn def_is_visible(&self, item: &ScopeDef) -> Visible {
549        match item {
550            ScopeDef::ModuleDef(def) => match def {
551                hir::ModuleDef::Module(it) => self.is_visible(it),
552                hir::ModuleDef::Function(it) => self.is_visible(it),
553                hir::ModuleDef::Adt(it) => self.is_visible(it),
554                hir::ModuleDef::EnumVariant(it) => self.is_visible(it),
555                hir::ModuleDef::Const(it) => self.is_visible(it),
556                hir::ModuleDef::Static(it) => self.is_visible(it),
557                hir::ModuleDef::Trait(it) => self.is_visible(it),
558                hir::ModuleDef::TypeAlias(it) => self.is_visible(it),
559                hir::ModuleDef::Macro(it) => self.is_visible(it),
560                hir::ModuleDef::BuiltinType(_) => Visible::Yes,
561            },
562            ScopeDef::GenericParam(_)
563            | ScopeDef::ImplSelfType(_)
564            | ScopeDef::AdtSelfType(_)
565            | ScopeDef::Local(_)
566            | ScopeDef::Label(_)
567            | ScopeDef::Unknown => Visible::Yes,
568        }
569    }
570
571    /// Checks if an item is visible, not `doc(hidden)` and stable at the completion site.
572    pub(crate) fn is_visible<I>(&self, item: &I) -> Visible
573    where
574        I: hir::HasVisibility + hir::HasAttrs + hir::HasCrate + Copy,
575    {
576        let vis = item.visibility(self.db);
577        let attrs = item.attrs(self.db);
578        self.is_visible_impl(&vis, &attrs, item.krate(self.db))
579    }
580
581    pub(crate) fn doc_aliases<I>(&self, item: &I) -> Vec<SmolStr>
582    where
583        I: hir::HasAttrs + Copy,
584    {
585        let attrs = item.attrs(self.db);
586        attrs.doc_aliases(self.db).iter().map(|it| it.as_str().into()).collect()
587    }
588
589    /// Check if an item is `#[doc(hidden)]`.
590    pub(crate) fn is_item_hidden(&self, item: &hir::ItemInNs) -> bool {
591        let attrs = item.attrs(self.db);
592        let krate = item.krate(self.db);
593        match (attrs, krate) {
594            (Some(attrs), Some(krate)) => self.is_doc_hidden(&attrs, krate),
595            _ => false,
596        }
597    }
598
599    /// Checks whether this item should be listed in regards to stability. Returns `true` if we should.
600    pub(crate) fn check_stability(&self, attrs: Option<&hir::AttrsWithOwner>) -> bool {
601        let Some(attrs) = attrs else {
602            return true;
603        };
604        if !attrs.is_unstable() {
605            return true;
606        }
607        if !self.is_nightly {
608            return false;
609        }
610        // Unstable on nightly, but we still don't want to suggest internal features, unless the feature flag is enabled.
611        let Some(unstable_feature) = attrs.unstable_feature(self.db) else {
612            return true;
613        };
614        !INTERNAL_FEATURES.contains(&unstable_feature)
615            || self.krate.is_unstable_feature_enabled(self.db, &unstable_feature)
616    }
617
618    pub(crate) fn check_stability_and_hidden<I>(&self, item: I) -> bool
619    where
620        I: hir::HasAttrs + hir::HasCrate,
621    {
622        let defining_crate = item.krate(self.db);
623        let attrs = item.attrs(self.db);
624        self.check_stability(Some(&attrs)) && !self.is_doc_hidden(&attrs, defining_crate)
625    }
626
627    /// Whether the given trait is an operator trait or not.
628    pub(crate) fn is_ops_trait(&self, trait_: hir::Trait) -> bool {
629        match trait_.attrs(self.db).lang(self.db) {
630            Some(lang) => OP_TRAIT_LANG.contains(&lang),
631            None => false,
632        }
633    }
634
635    /// Whether the given trait has `#[doc(notable_trait)]`
636    pub(crate) fn is_doc_notable_trait(&self, trait_: hir::Trait) -> bool {
637        trait_.attrs(self.db).is_doc_notable_trait()
638    }
639
640    /// Returns the traits in scope, with the [`Drop`] trait removed.
641    pub(crate) fn traits_in_scope(&self) -> hir::VisibleTraits {
642        let mut traits_in_scope = self.scope.visible_traits();
643        if let Some(drop) = self.famous_defs().core_ops_Drop() {
644            traits_in_scope.0.remove(&drop.into());
645        }
646        traits_in_scope
647    }
648
649    pub(crate) fn iterate_path_candidates(
650        &self,
651        ty: &hir::Type<'_>,
652        mut cb: impl FnMut(hir::AssocItem),
653    ) {
654        let mut seen = FxHashSet::default();
655        ty.iterate_path_candidates(self.db, &self.scope, &self.traits_in_scope(), None, |item| {
656            // We might iterate candidates of a trait multiple times here, so deduplicate
657            // them.
658            if seen.insert(item) {
659                cb(item)
660            }
661            None::<()>
662        });
663    }
664
665    /// A version of [`SemanticsScope::process_all_names`] that filters out `#[doc(hidden)]` items and
666    /// passes all doc-aliases along, to funnel it into `Completions::add_path_resolution`.
667    pub(crate) fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef, Vec<SmolStr>)) {
668        let _p = tracing::info_span!("CompletionContext::process_all_names").entered();
669        self.scope.process_all_names(&mut |name, def| {
670            if self.is_scope_def_hidden(def) {
671                return;
672            }
673            let doc_aliases = self.doc_aliases_in_scope(def);
674            f(name, def, doc_aliases);
675        });
676    }
677
678    pub(crate) fn process_all_names_raw(&self, f: &mut dyn FnMut(Name, ScopeDef)) {
679        let _p = tracing::info_span!("CompletionContext::process_all_names_raw").entered();
680        self.scope.process_all_names(f);
681    }
682
683    fn is_scope_def_hidden(&self, scope_def: ScopeDef) -> bool {
684        if let (Some(attrs), Some(krate)) = (scope_def.attrs(self.db), scope_def.krate(self.db)) {
685            return self.is_doc_hidden(&attrs, krate);
686        }
687
688        false
689    }
690
691    fn is_visible_impl(
692        &self,
693        vis: &hir::Visibility,
694        attrs: &hir::AttrsWithOwner,
695        defining_crate: hir::Crate,
696    ) -> Visible {
697        if !self.check_stability(Some(attrs)) {
698            return Visible::No;
699        }
700
701        if !vis.is_visible_from(self.db, self.module.into()) {
702            if !self.config.enable_private_editable {
703                return Visible::No;
704            }
705            // If the definition location is editable, also show private items
706            return if is_editable_crate(defining_crate, self.db) {
707                Visible::Editable
708            } else {
709                Visible::No
710            };
711        }
712
713        if self.is_doc_hidden(attrs, defining_crate) { Visible::No } else { Visible::Yes }
714    }
715
716    pub(crate) fn is_doc_hidden(
717        &self,
718        attrs: &hir::AttrsWithOwner,
719        defining_crate: hir::Crate,
720    ) -> bool {
721        // `doc(hidden)` items are only completed within the defining crate.
722        self.krate != defining_crate && attrs.is_doc_hidden()
723    }
724
725    pub(crate) fn doc_aliases_in_scope(&self, scope_def: ScopeDef) -> Vec<SmolStr> {
726        if let Some(attrs) = scope_def.attrs(self.db) {
727            attrs.doc_aliases(self.db).iter().map(|it| it.as_str().into()).collect()
728        } else {
729            vec![]
730        }
731    }
732}
733
734// CompletionContext construction
735impl<'a, 'db> CompletionContext<'a, 'db> {
736    pub(crate) fn new(
737        db: &'db RootDatabase,
738        position @ FilePosition { file_id, offset }: FilePosition,
739        config: &'a CompletionConfig<'a>,
740        trigger_character: Option<char>,
741    ) -> Option<(CompletionContext<'a, 'db>, CompletionAnalysis<'db>)> {
742        let _p = tracing::info_span!("CompletionContext::new").entered();
743        let sema = Semantics::new(db);
744
745        let editioned_file_id = sema.attach_first_edition(file_id);
746        let original_file = sema.parse(editioned_file_id);
747
748        // Insert a fake ident to get a valid parse tree. We will use this file
749        // to determine context, though the original_file will be used for
750        // actual completion.
751        let file_with_fake_ident = {
752            let (_, edition) = editioned_file_id.unpack(db);
753            let parse = editioned_file_id.parse(db);
754            parse.reparse(TextRange::empty(offset), COMPLETION_MARKER, edition).tree()
755        };
756
757        // always pick the token to the immediate left of the cursor, as that is what we are actually
758        // completing on
759        let original_token = original_file.syntax().token_at_offset(offset).left_biased()?;
760
761        // try to skip completions on path with invalid colons
762        // this approach works in normal path and inside token tree
763        if original_token.kind() == T![:] {
764            // return if no prev token before colon
765            let prev_token = original_token.prev_token()?;
766
767            // only has a single colon
768            if prev_token.kind() != T![:] && !is_in_macro_matcher(&original_token) {
769                return None;
770            }
771
772            // has 3 colon or 2 coloncolon in a row
773            // special casing this as per discussion in https://github.com/rust-lang/rust-analyzer/pull/13611#discussion_r1031845205
774            // and https://github.com/rust-lang/rust-analyzer/pull/13611#discussion_r1032812751
775            if prev_token
776                .prev_token()
777                .map(|t| t.kind() == T![:] || t.kind() == T![::])
778                .unwrap_or(false)
779            {
780                return None;
781            }
782        }
783
784        let AnalysisResult {
785            analysis,
786            expected: (expected_type, expected_name),
787            qualifier_ctx,
788            token,
789            original_offset,
790        } = expand_and_analyze(
791            &sema,
792            InFile::new(editioned_file_id.into(), original_file.syntax().clone()),
793            file_with_fake_ident.syntax().clone(),
794            offset,
795            &original_token,
796        )?;
797
798        // adjust for macro input, this still fails if there is no token written yet
799        let scope = sema.scope_at_offset(&token.parent()?, original_offset)?;
800
801        let krate = scope.krate();
802        let module = scope.module();
803        let containing_function = scope.containing_function();
804        let edition = krate.edition(db);
805
806        let toolchain = toolchain_channel(db, krate.into());
807        // `toolchain == None` means we're in some detached files. Since we have no information on
808        // the toolchain being used, let's just allow unstable items to be listed.
809        let is_nightly = matches!(toolchain, Some(base_db::ReleaseChannel::Nightly) | None);
810
811        let mut locals = FxHashMap::default();
812        scope.process_all_names(&mut |name, scope| {
813            if let ScopeDef::Local(local) = scope {
814                // synthetic names currently leak out as we lack synthetic hygiene, so filter them
815                // out here
816                if name.as_str().starts_with('<') {
817                    return;
818                }
819                locals.insert(name, local);
820            }
821        });
822
823        let depth_from_crate_root = iter::successors(Some(module), |m| m.parent(db))
824            // `BlockExpr` modules do not count towards module depth
825            .filter(|m| !matches!(m.definition_source(db).value, ModuleSource::BlockExpr(_)))
826            .count()
827            // exclude `m` itself
828            .saturating_sub(1);
829
830        let exclude_traits: FxHashSet<_> = config
831            .exclude_traits
832            .iter()
833            .filter_map(|path| {
834                hir::resolve_absolute_path(db, path.split("::").map(Symbol::intern)).find_map(
835                    |it| match it {
836                        hir::ItemInNs::Types(ModuleDef::Trait(t)) => Some(t),
837                        _ => None,
838                    },
839                )
840            })
841            .collect();
842
843        let mut exclude_flyimport: FxHashMap<_, _> = config
844            .exclude_flyimport
845            .iter()
846            .flat_map(|(path, kind)| {
847                hir::resolve_absolute_path(db, path.split("::").map(Symbol::intern))
848                    .map(|it| (it.into_module_def(), *kind))
849            })
850            .collect();
851        exclude_flyimport
852            .extend(exclude_traits.iter().map(|&t| (t.into(), AutoImportExclusionType::Always)));
853
854        // FIXME: This should be part of `CompletionAnalysis` / `expand_and_analyze`
855        let complete_semicolon = if !config.add_semicolon_to_unit {
856            CompleteSemicolon::DoNotComplete
857        } else if let Some(term_node) =
858            sema.token_ancestors_with_macros(token.clone()).find(|node| {
859                matches!(
860                    node.kind(),
861                    BLOCK_EXPR | MATCH_ARM | CLOSURE_EXPR | ARG_LIST | PAREN_EXPR | ARRAY_EXPR
862                )
863            })
864        {
865            let next_token = iter::successors(token.next_token(), |it| it.next_token())
866                .map(|it| it.kind())
867                .find(|kind| !kind.is_trivia());
868            match term_node.kind() {
869                MATCH_ARM if next_token != Some(T![,]) => CompleteSemicolon::CompleteComma,
870                BLOCK_EXPR if next_token != Some(T![;]) => CompleteSemicolon::CompleteSemi,
871                _ => CompleteSemicolon::DoNotComplete,
872            }
873        } else {
874            CompleteSemicolon::DoNotComplete
875        };
876
877        let display_target = krate.to_display_target(db);
878        let ctx = CompletionContext {
879            sema,
880            scope,
881            db,
882            config,
883            position,
884            trigger_character,
885            original_token,
886            token,
887            krate,
888            module,
889            containing_function,
890            is_nightly,
891            edition,
892            expected_name,
893            expected_type,
894            qualifier_ctx,
895            locals,
896            depth_from_crate_root,
897            exclude_flyimport,
898            exclude_traits,
899            complete_semicolon,
900            display_target,
901        };
902        Some((ctx, analysis))
903    }
904}
905
906const OP_TRAIT_LANG: &[hir::LangItem] = &[
907    hir::LangItem::AddAssign,
908    hir::LangItem::Add,
909    hir::LangItem::BitAndAssign,
910    hir::LangItem::BitAnd,
911    hir::LangItem::BitOrAssign,
912    hir::LangItem::BitOr,
913    hir::LangItem::BitXorAssign,
914    hir::LangItem::BitXor,
915    hir::LangItem::DerefMut,
916    hir::LangItem::Deref,
917    hir::LangItem::DivAssign,
918    hir::LangItem::Div,
919    hir::LangItem::PartialEq,
920    hir::LangItem::FnMut,
921    hir::LangItem::FnOnce,
922    hir::LangItem::Fn,
923    hir::LangItem::IndexMut,
924    hir::LangItem::Index,
925    hir::LangItem::MulAssign,
926    hir::LangItem::Mul,
927    hir::LangItem::Neg,
928    hir::LangItem::Not,
929    hir::LangItem::PartialOrd,
930    hir::LangItem::RemAssign,
931    hir::LangItem::Rem,
932    hir::LangItem::ShlAssign,
933    hir::LangItem::Shl,
934    hir::LangItem::ShrAssign,
935    hir::LangItem::Shr,
936    hir::LangItem::Sub,
937];
938
939// FIXME: Find a way to keep this up to date somehow?
940const INTERNAL_FEATURES_LIST: &[Symbol] = &[
941    sym::abi_unadjusted,
942    sym::allocator_internals,
943    sym::allow_internal_unsafe,
944    sym::allow_internal_unstable,
945    sym::cfg_emscripten_wasm_eh,
946    sym::cfg_target_has_reliable_f16_f128,
947    sym::compiler_builtins,
948    sym::custom_mir,
949    sym::eii_internals,
950    sym::field_representing_type_raw,
951    sym::intrinsics,
952    sym::lang_items,
953    sym::link_cfg,
954    sym::more_maybe_bounds,
955    sym::negative_bounds,
956    sym::pattern_complexity_limit,
957    sym::prelude_import,
958    sym::profiler_runtime,
959    sym::rustc_attrs,
960    sym::staged_api,
961    sym::test_unstable_lint,
962    sym::builtin_syntax,
963    sym::link_llvm_intrinsics,
964    sym::needs_panic_runtime,
965    sym::panic_runtime,
966    sym::pattern_types,
967    sym::rustdoc_internals,
968    sym::contracts_internals,
969    sym::freeze_impls,
970    sym::unsized_fn_params,
971];
972
973static INTERNAL_FEATURES: LazyLock<FxHashSet<Symbol>> =
974    LazyLock::new(|| INTERNAL_FEATURES_LIST.iter().cloned().collect());
ide_completion/context.rs

ide_completion/
context.rs
