From 5fe19d2fbd2daa05b2cd3b1ebb6fa926e9d86c36 Mon Sep 17 00:00:00 2001 From: Ekaterina Babshukova Date: Sun, 21 Jul 2019 14:11:45 +0300 Subject: provide completion in struct patterns --- crates/ra_hir/src/source_binder.rs | 9 ++- crates/ra_hir/src/ty.rs | 2 +- crates/ra_hir/src/ty/infer.rs | 22 +++-- crates/ra_ide_api/src/completion.rs | 2 + .../src/completion/complete_struct_literal.rs | 15 ++-- .../src/completion/complete_struct_pattern.rs | 94 ++++++++++++++++++++++ .../src/completion/completion_context.rs | 11 ++- 7 files changed, 134 insertions(+), 21 deletions(-) create mode 100644 crates/ra_ide_api/src/completion/complete_struct_pattern.rs (limited to 'crates') diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index 4c173a4f7..fc9bc33d2 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs @@ -266,9 +266,14 @@ impl SourceAnalyzer { self.infer.as_ref()?.field_resolution(expr_id) } - pub fn resolve_variant(&self, struct_lit: &ast::StructLit) -> Option { + pub fn resolve_struct_literal(&self, struct_lit: &ast::StructLit) -> Option { let expr_id = self.body_source_map.as_ref()?.node_expr(&struct_lit.clone().into())?; - self.infer.as_ref()?.variant_resolution(expr_id) + self.infer.as_ref()?.variant_resolution_for_expr(expr_id) + } + + pub fn resolve_struct_pattern(&self, struct_pat: &ast::StructPat) -> Option { + let pat_id = self.body_source_map.as_ref()?.node_pat(&struct_pat.clone().into())?; + self.infer.as_ref()?.variant_resolution_for_pat(pat_id) } pub fn resolve_macro_call( diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index 4cf714f5d..82589e504 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -472,7 +472,7 @@ impl Ty { /// Returns the type parameters of this type if it has some (i.e. is an ADT /// or function); so if `self` is `Option`, this returns the `u32`. - fn substs(&self) -> Option { + pub fn substs(&self) -> Option { match self { Ty::Apply(ApplicationTy { parameters, .. }) => Some(parameters.clone()), _ => None, diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index a82dff711..594c5bc79 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -113,7 +113,8 @@ pub struct InferenceResult { method_resolutions: FxHashMap, /// For each field access expr, records the field it resolves to. field_resolutions: FxHashMap, - variant_resolutions: FxHashMap, + /// For each struct literal, records the variant it resolves to. + variant_resolutions: FxHashMap, /// For each associated item record what it resolves to assoc_resolutions: FxHashMap, diagnostics: Vec, @@ -128,8 +129,11 @@ impl InferenceResult { pub fn field_resolution(&self, expr: ExprId) -> Option { self.field_resolutions.get(&expr).copied() } - pub fn variant_resolution(&self, expr: ExprId) -> Option { - self.variant_resolutions.get(&expr).copied() + pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option { + self.variant_resolutions.get(&id.into()).copied() + } + pub fn variant_resolution_for_pat(&self, id: PatId) -> Option { + self.variant_resolutions.get(&id.into()).copied() } pub fn assoc_resolutions_for_expr(&self, id: ExprId) -> Option { self.assoc_resolutions.get(&id.into()).copied() @@ -218,8 +222,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { self.result.field_resolutions.insert(expr, field); } - fn write_variant_resolution(&mut self, expr: ExprId, variant: VariantDef) { - self.result.variant_resolutions.insert(expr, variant); + fn write_variant_resolution(&mut self, id: ExprOrPatId, variant: VariantDef) { + self.result.variant_resolutions.insert(id, variant); } fn write_assoc_resolution(&mut self, id: ExprOrPatId, item: ImplItem) { @@ -678,8 +682,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { subpats: &[FieldPat], expected: &Ty, default_bm: BindingMode, + id: PatId, ) -> Ty { let (ty, def) = self.resolve_variant(path); + if let Some(variant) = def { + self.write_variant_resolution(id.into(), variant); + } self.unify(&ty, expected); @@ -762,7 +770,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm) } Pat::Struct { path: ref p, args: ref fields } => { - self.infer_struct_pat(p.as_ref(), fields, expected, default_bm) + self.infer_struct_pat(p.as_ref(), fields, expected, default_bm, pat) } Pat::Path(path) => { // FIXME use correct resolver for the surrounding expression @@ -1064,7 +1072,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { Expr::StructLit { path, fields, spread } => { let (ty, def_id) = self.resolve_variant(path.as_ref()); if let Some(variant) = def_id { - self.write_variant_resolution(tgt_expr, variant); + self.write_variant_resolution(tgt_expr.into(), variant); } let substs = ty.substs().unwrap_or_else(Substs::empty); diff --git a/crates/ra_ide_api/src/completion.rs b/crates/ra_ide_api/src/completion.rs index c23b5da59..85160358a 100644 --- a/crates/ra_ide_api/src/completion.rs +++ b/crates/ra_ide_api/src/completion.rs @@ -4,6 +4,7 @@ mod presentation; mod complete_dot; mod complete_struct_literal; +mod complete_struct_pattern; mod complete_pattern; mod complete_fn_param; mod complete_keyword; @@ -65,6 +66,7 @@ pub(crate) fn completions(db: &db::RootDatabase, position: FilePosition) -> Opti complete_scope::complete_scope(&mut acc, &ctx); complete_dot::complete_dot(&mut acc, &ctx); complete_struct_literal::complete_struct_literal(&mut acc, &ctx); + complete_struct_pattern::complete_struct_pattern(&mut acc, &ctx); complete_pattern::complete_pattern(&mut acc, &ctx); complete_postfix::complete_postfix(&mut acc, &ctx); Some(acc) diff --git a/crates/ra_ide_api/src/completion/complete_struct_literal.rs b/crates/ra_ide_api/src/completion/complete_struct_literal.rs index 9410f740f..6aa41f498 100644 --- a/crates/ra_ide_api/src/completion/complete_struct_literal.rs +++ b/crates/ra_ide_api/src/completion/complete_struct_literal.rs @@ -1,23 +1,22 @@ -use hir::{Substs, Ty}; +use hir::Substs; use crate::completion::{CompletionContext, Completions}; /// Complete fields in fields literals. pub(super) fn complete_struct_literal(acc: &mut Completions, ctx: &CompletionContext) { let (ty, variant) = match ctx.struct_lit_syntax.as_ref().and_then(|it| { - Some((ctx.analyzer.type_of(ctx.db, &it.clone().into())?, ctx.analyzer.resolve_variant(it)?)) + Some(( + ctx.analyzer.type_of(ctx.db, &it.clone().into())?, + ctx.analyzer.resolve_struct_literal(it)?, + )) }) { Some(it) => it, _ => return, }; - - let ty_substs = match ty { - Ty::Apply(it) => it.parameters, - _ => Substs::empty(), - }; + let substs = &ty.substs().unwrap_or_else(Substs::empty); for field in variant.fields(ctx.db) { - acc.add_field(ctx, field, &ty_substs); + acc.add_field(ctx, field, substs); } } diff --git a/crates/ra_ide_api/src/completion/complete_struct_pattern.rs b/crates/ra_ide_api/src/completion/complete_struct_pattern.rs new file mode 100644 index 000000000..d0dde5930 --- /dev/null +++ b/crates/ra_ide_api/src/completion/complete_struct_pattern.rs @@ -0,0 +1,94 @@ +use hir::Substs; + +use crate::completion::{CompletionContext, Completions}; + +pub(super) fn complete_struct_pattern(acc: &mut Completions, ctx: &CompletionContext) { + let (ty, variant) = match ctx.struct_lit_pat.as_ref().and_then(|it| { + Some(( + ctx.analyzer.type_of_pat(ctx.db, &it.clone().into())?, + ctx.analyzer.resolve_struct_pattern(it)?, + )) + }) { + Some(it) => it, + _ => return, + }; + let substs = &ty.substs().unwrap_or_else(Substs::empty); + + for field in variant.fields(ctx.db) { + acc.add_field(ctx, field, substs); + } +} + +#[cfg(test)] +mod tests { + use crate::completion::{do_completion, CompletionItem, CompletionKind}; + use insta::assert_debug_snapshot_matches; + + fn complete(code: &str) -> Vec { + do_completion(code, CompletionKind::Reference) + } + + #[test] + fn test_struct_pattern_field() { + let completions = complete( + r" + struct S { foo: u32 } + + fn process(f: S) { + match f { + S { f<|>: 92 } => (), + } + } + ", + ); + assert_debug_snapshot_matches!(completions, @r###" + ⋮[ + ⋮ CompletionItem { + ⋮ label: "foo", + ⋮ source_range: [117; 118), + ⋮ delete: [117; 118), + ⋮ insert: "foo", + ⋮ kind: Field, + ⋮ detail: "u32", + ⋮ }, + ⋮] + "###); + } + + #[test] + fn test_struct_pattern_enum_variant() { + let completions = complete( + r" + enum E { + S { foo: u32, bar: () } + } + + fn process(e: E) { + match e { + E::S { <|> } => (), + } + } + ", + ); + assert_debug_snapshot_matches!(completions, @r###" + ⋮[ + ⋮ CompletionItem { + ⋮ label: "bar", + ⋮ source_range: [161; 161), + ⋮ delete: [161; 161), + ⋮ insert: "bar", + ⋮ kind: Field, + ⋮ detail: "()", + ⋮ }, + ⋮ CompletionItem { + ⋮ label: "foo", + ⋮ source_range: [161; 161), + ⋮ delete: [161; 161), + ⋮ insert: "foo", + ⋮ kind: Field, + ⋮ detail: "u32", + ⋮ }, + ⋮] + "###); + } +} diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs index 2f78d5409..6fee7b5be 100644 --- a/crates/ra_ide_api/src/completion/completion_context.rs +++ b/crates/ra_ide_api/src/completion/completion_context.rs @@ -21,6 +21,7 @@ pub(crate) struct CompletionContext<'a> { pub(super) function_syntax: Option, pub(super) use_item_syntax: Option, pub(super) struct_lit_syntax: Option, + pub(super) struct_lit_pat: Option, pub(super) is_param: bool, /// If a name-binding or reference to a const in a pattern. /// Irrefutable patterns (like let) are excluded. @@ -60,6 +61,7 @@ impl<'a> CompletionContext<'a> { function_syntax: None, use_item_syntax: None, struct_lit_syntax: None, + struct_lit_pat: None, is_param: false, is_pat_binding: false, is_trivial_path: false, @@ -106,8 +108,7 @@ impl<'a> CompletionContext<'a> { // Otherwise, see if this is a declaration. We can use heuristics to // suggest declaration names, see `CompletionKind::Magic`. if let Some(name) = find_node_at_offset::(file.syntax(), offset) { - if is_node::(name.syntax()) { - let bind_pat = name.syntax().ancestors().find_map(ast::BindPat::cast).unwrap(); + if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) { let parent = bind_pat.syntax().parent(); if parent.clone().and_then(ast::MatchArm::cast).is_some() || parent.and_then(ast::Condition::cast).is_some() @@ -119,6 +120,10 @@ impl<'a> CompletionContext<'a> { self.is_param = true; return; } + if name.syntax().ancestors().find_map(ast::FieldPatList::cast).is_some() { + self.struct_lit_pat = + find_node_at_offset(original_parse.tree().syntax(), self.offset); + } } } @@ -235,7 +240,7 @@ fn find_node_with_range(syntax: &SyntaxNode, range: TextRange) -> Op } fn is_node(node: &SyntaxNode) -> bool { - match node.ancestors().filter_map(N::cast).next() { + match node.ancestors().find_map(N::cast) { None => false, Some(n) => n.syntax().text_range() == node.text_range(), } -- cgit v1.2.3