};
use syntax::{
algo::find_node_at_offset,
- ast::{self, NameOrNameRef, NameOwner},
+ ast::{self, HasName, NameOrNameRef},
match_ast, AstNode, NodeOrToken,
SyntaxKind::{self, *},
SyntaxNode, SyntaxToken, TextRange, TextSize, T,
pub(super) is_param: Option<ParamKind>,
}
+#[derive(Debug)]
+pub(super) enum LifetimeContext {
+ LifetimeParam(Option<ast::LifetimeParam>),
+ Lifetime,
+ LabelRef,
+ LabelDef,
+}
+
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub(crate) enum CallKind {
Pat,
pub(super) original_token: SyntaxToken,
/// The token before the cursor, in the macro-expanded file.
pub(super) token: SyntaxToken,
+ /// The crate of the current file.
pub(super) krate: Option<hir::Crate>,
pub(super) expected_name: Option<NameOrNameRef>,
pub(super) expected_type: Option<Type>,
pub(super) impl_def: Option<ast::Impl>,
pub(super) name_syntax: Option<ast::NameLike>,
- // potentially set if we are completing a lifetime
- pub(super) lifetime_param_syntax: Option<ast::LifetimeParam>,
- pub(super) lifetime_allowed: bool,
- pub(super) is_label_ref: bool,
-
pub(super) completion_location: Option<ImmediateLocation>,
pub(super) prev_sibling: Option<ImmediatePrevSibling>,
pub(super) attribute_under_caret: Option<ast::Attr>,
pub(super) previous_token: Option<SyntaxToken>,
+ pub(super) lifetime_ctx: Option<LifetimeContext>,
pub(super) pattern_ctx: Option<PatternContext>,
pub(super) path_context: Option<PathCompletionContext>,
pub(super) locals: Vec<(String, Local)>,
let fake_ident_token =
file_with_fake_ident.syntax().token_at_offset(position.offset).right_biased().unwrap();
- let krate = sema.to_module_def(position.file_id).map(|m| m.krate());
let original_token =
original_file.syntax().token_at_offset(position.offset).left_biased()?;
- let token = sema.descend_into_macros(original_token.clone());
+ let token = sema.descend_into_macros_single(original_token.clone());
let scope = sema.scope_at_offset(&token, position.offset);
+ let krate = scope.krate();
let mut locals = vec![];
scope.process_all_names(&mut |name, scope| {
if let ScopeDef::Local(local) = scope {
function_def: None,
impl_def: None,
name_syntax: None,
- lifetime_param_syntax: None,
- lifetime_allowed: false,
- is_label_ref: false,
+ lifetime_ctx: None,
pattern_ctx: None,
completion_location: None,
prev_sibling: None,
Some(ctx)
}
+ /// Do the attribute expansion at the current cursor position for both original file and fake file
+ /// as long as possible. As soon as one of the two expansions fail we stop to stay in sync.
fn expand_and_fill(
&mut self,
mut original_file: SyntaxNode,
self.previous_token.as_ref().map_or(false, |tok| tok.kind() == kind)
}
- pub(crate) fn expects_assoc_item(&self) -> bool {
- matches!(self.completion_location, Some(ImmediateLocation::Trait | ImmediateLocation::Impl))
+ pub(crate) fn dot_receiver(&self) -> Option<&ast::Expr> {
+ match &self.completion_location {
+ Some(
+ ImmediateLocation::MethodCall { receiver, .. }
+ | ImmediateLocation::FieldAccess { receiver, .. },
+ ) => receiver.as_ref(),
+ _ => None,
+ }
}
pub(crate) fn has_dot_receiver(&self) -> bool {
)
}
- pub(crate) fn dot_receiver(&self) -> Option<&ast::Expr> {
- match &self.completion_location {
- Some(
- ImmediateLocation::MethodCall { receiver, .. }
- | ImmediateLocation::FieldAccess { receiver, .. },
- ) => receiver.as_ref(),
- _ => None,
- }
+ pub(crate) fn expects_assoc_item(&self) -> bool {
+ matches!(self.completion_location, Some(ImmediateLocation::Trait | ImmediateLocation::Impl))
}
pub(crate) fn expects_non_trait_assoc_item(&self) -> bool {
}
pub(crate) fn has_block_expr_parent(&self) -> bool {
- matches!(self.completion_location, Some(ImmediateLocation::BlockExpr))
+ matches!(self.completion_location, Some(ImmediateLocation::StmtList))
}
pub(crate) fn expects_ident_pat_or_ref_expr(&self) -> bool {
| ImmediateLocation::ModDeclaration(_)
| ImmediateLocation::RecordPat(_)
| ImmediateLocation::RecordExpr(_)
+ | ImmediateLocation::Rename
)
)
}
false
}
+ /// Check if an item is `#[doc(hidden)]`.
pub(crate) fn is_item_hidden(&self, item: &hir::ItemInNs) -> bool {
let attrs = item.attrs(self.db);
let krate = item.krate(self.db);
}
fn is_doc_hidden(&self, attrs: &hir::Attrs, defining_crate: hir::Crate) -> bool {
- let module = match self.scope.module() {
+ let krate = match self.krate {
Some(it) => it,
None => return true,
};
- if module.krate() != defining_crate && attrs.has_doc_hidden() {
+ if krate != defining_crate && attrs.has_doc_hidden() {
// `doc(hidden)` items are only completed within the defining crate.
return true;
}
.and_then(|pat| self.sema.type_of_pat(&pat))
.or_else(|| it.initializer().and_then(|it| self.sema.type_of_expr(&it)))
.map(TypeInfo::original);
- let name = if let Some(ast::Pat::IdentPat(ident)) = it.pat() {
- ident.name().map(NameOrNameRef::Name)
- } else {
- None
+ let name = match it.pat() {
+ Some(ast::Pat::IdentPat(ident)) => ident.name().map(NameOrNameRef::Name),
+ Some(_) | None => None,
};
(ty, name)
return;
}
- match_ast! {
+ self.lifetime_ctx = Some(match_ast! {
match parent {
- ast::LifetimeParam(_it) => {
- self.lifetime_allowed = true;
- self.lifetime_param_syntax =
- self.sema.find_node_at_offset_with_macros(original_file, offset);
- },
- ast::BreakExpr(_it) => self.is_label_ref = true,
- ast::ContinueExpr(_it) => self.is_label_ref = true,
- ast::Label(_it) => (),
- _ => self.lifetime_allowed = true,
+ ast::LifetimeParam(_it) => LifetimeContext::LifetimeParam(self.sema.find_node_at_offset_with_macros(original_file, offset)),
+ ast::BreakExpr(_it) => LifetimeContext::LabelRef,
+ ast::ContinueExpr(_it) => LifetimeContext::LabelRef,
+ ast::Label(_it) => LifetimeContext::LabelDef,
+ _ => LifetimeContext::Lifetime,
}
- }
+ });
}
}
if let Some(stmt) = ast::ExprStmt::cast(node.clone()) {
return Some(stmt.syntax().text_range() == name_ref.syntax().text_range());
}
- if let Some(block) = ast::BlockExpr::cast(node) {
+ if let Some(stmt_list) = ast::StmtList::cast(node) {
return Some(
- block.tail_expr().map(|e| e.syntax().text_range())
+ stmt_list.tail_expr().map(|e| e.syntax().text_range())
== Some(name_ref.syntax().text_range()),
);
}
fn check_expected_type_and_name(ra_fixture: &str, expect: Expect) {
let (db, pos) = position(ra_fixture);
- let completion_context = CompletionContext::new(&db, pos, &TEST_CONFIG).unwrap();
+ let config = TEST_CONFIG;
+ let completion_context = CompletionContext::new(&db, pos, &config).unwrap();
let ty = completion_context
.expected_type
projects / rust.git / blobdiff