diff options
author | rdambrosio <[email protected]> | 2021-06-18 00:54:28 +0100 |
---|---|---|
committer | rdambrosio <[email protected]> | 2021-06-18 00:54:28 +0100 |
commit | 8e08b86304f8cf91e06f64855c8de306ad7efaa4 (patch) | |
tree | 134d42353a19d61fd7ebefd129fd7924c1d205f4 /crates/ide_assists | |
parent | 0d863ccea96c6c3256fad12807a0eedbfccd8294 (diff) |
Feat: inline generics in const and func trait completions
Diffstat (limited to 'crates/ide_assists')
-rw-r--r-- | crates/ide_assists/src/lib.rs | 1 | ||||
-rw-r--r-- | crates/ide_assists/src/path_transform.rs | 160 | ||||
-rw-r--r-- | crates/ide_assists/src/utils.rs | 6 |
3 files changed, 2 insertions, 165 deletions
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs index fa378a622..86a57ce5d 100644 --- a/crates/ide_assists/src/lib.rs +++ b/crates/ide_assists/src/lib.rs | |||
@@ -15,7 +15,6 @@ mod assist_context; | |||
15 | #[cfg(test)] | 15 | #[cfg(test)] |
16 | mod tests; | 16 | mod tests; |
17 | pub mod utils; | 17 | pub mod utils; |
18 | pub mod path_transform; | ||
19 | 18 | ||
20 | use hir::Semantics; | 19 | use hir::Semantics; |
21 | use ide_db::{base_db::FileRange, RootDatabase}; | 20 | use ide_db::{base_db::FileRange, RootDatabase}; |
diff --git a/crates/ide_assists/src/path_transform.rs b/crates/ide_assists/src/path_transform.rs deleted file mode 100644 index 48a7fa06a..000000000 --- a/crates/ide_assists/src/path_transform.rs +++ /dev/null | |||
@@ -1,160 +0,0 @@ | |||
1 | //! See [`PathTransform`]. | ||
2 | |||
3 | use hir::{HirDisplay, SemanticsScope}; | ||
4 | use ide_db::helpers::mod_path_to_ast; | ||
5 | use rustc_hash::FxHashMap; | ||
6 | use syntax::{ | ||
7 | ast::{self, AstNode}, | ||
8 | ted, | ||
9 | }; | ||
10 | |||
11 | /// `PathTransform` substitutes path in SyntaxNodes in bulk. | ||
12 | /// | ||
13 | /// This is mostly useful for IDE code generation. If you paste some existing | ||
14 | /// code into a new context (for example, to add method overrides to an `impl` | ||
15 | /// block), you generally want to appropriately qualify the names, and sometimes | ||
16 | /// you might want to substitute generic parameters as well: | ||
17 | /// | ||
18 | /// ``` | ||
19 | /// mod x { | ||
20 | /// pub struct A<V>; | ||
21 | /// pub trait T<U> { fn foo(&self, _: U) -> A<U>; } | ||
22 | /// } | ||
23 | /// | ||
24 | /// mod y { | ||
25 | /// use x::T; | ||
26 | /// | ||
27 | /// impl T<()> for () { | ||
28 | /// // If we invoke **Add Missing Members** here, we want to copy-paste `foo`. | ||
29 | /// // But we want a slightly-modified version of it: | ||
30 | /// fn foo(&self, _: ()) -> x::A<()> {} | ||
31 | /// } | ||
32 | /// } | ||
33 | /// ``` | ||
34 | pub(crate) struct PathTransform<'a> { | ||
35 | pub(crate) subst: (hir::Trait, ast::Impl), | ||
36 | pub(crate) target_scope: &'a SemanticsScope<'a>, | ||
37 | pub(crate) source_scope: &'a SemanticsScope<'a>, | ||
38 | } | ||
39 | |||
40 | impl<'a> PathTransform<'a> { | ||
41 | pub(crate) fn apply(&self, item: ast::AssocItem) { | ||
42 | if let Some(ctx) = self.build_ctx() { | ||
43 | ctx.apply(item) | ||
44 | } | ||
45 | } | ||
46 | fn build_ctx(&self) -> Option<Ctx<'a>> { | ||
47 | let db = self.source_scope.db; | ||
48 | let target_module = self.target_scope.module()?; | ||
49 | let source_module = self.source_scope.module()?; | ||
50 | |||
51 | let substs = get_syntactic_substs(self.subst.1.clone()).unwrap_or_default(); | ||
52 | let generic_def: hir::GenericDef = self.subst.0.into(); | ||
53 | let substs_by_param: FxHashMap<_, _> = generic_def | ||
54 | .type_params(db) | ||
55 | .into_iter() | ||
56 | // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky | ||
57 | .skip(1) | ||
58 | // The actual list of trait type parameters may be longer than the one | ||
59 | // used in the `impl` block due to trailing default type parameters. | ||
60 | // For that case we extend the `substs` with an empty iterator so we | ||
61 | // can still hit those trailing values and check if they actually have | ||
62 | // a default type. If they do, go for that type from `hir` to `ast` so | ||
63 | // the resulting change can be applied correctly. | ||
64 | .zip(substs.into_iter().map(Some).chain(std::iter::repeat(None))) | ||
65 | .filter_map(|(k, v)| match v { | ||
66 | Some(v) => Some((k, v)), | ||
67 | None => { | ||
68 | let default = k.default(db)?; | ||
69 | Some(( | ||
70 | k, | ||
71 | ast::make::ty(&default.display_source_code(db, source_module.into()).ok()?), | ||
72 | )) | ||
73 | } | ||
74 | }) | ||
75 | .collect(); | ||
76 | |||
77 | let res = Ctx { substs: substs_by_param, target_module, source_scope: self.source_scope }; | ||
78 | Some(res) | ||
79 | } | ||
80 | } | ||
81 | |||
82 | struct Ctx<'a> { | ||
83 | substs: FxHashMap<hir::TypeParam, ast::Type>, | ||
84 | target_module: hir::Module, | ||
85 | source_scope: &'a SemanticsScope<'a>, | ||
86 | } | ||
87 | |||
88 | impl<'a> Ctx<'a> { | ||
89 | fn apply(&self, item: ast::AssocItem) { | ||
90 | for event in item.syntax().preorder() { | ||
91 | let node = match event { | ||
92 | syntax::WalkEvent::Enter(_) => continue, | ||
93 | syntax::WalkEvent::Leave(it) => it, | ||
94 | }; | ||
95 | if let Some(path) = ast::Path::cast(node.clone()) { | ||
96 | self.transform_path(path); | ||
97 | } | ||
98 | } | ||
99 | } | ||
100 | fn transform_path(&self, path: ast::Path) -> Option<()> { | ||
101 | if path.qualifier().is_some() { | ||
102 | return None; | ||
103 | } | ||
104 | if path.segment().and_then(|s| s.param_list()).is_some() { | ||
105 | // don't try to qualify `Fn(Foo) -> Bar` paths, they are in prelude anyway | ||
106 | return None; | ||
107 | } | ||
108 | |||
109 | let resolution = self.source_scope.speculative_resolve(&path)?; | ||
110 | |||
111 | match resolution { | ||
112 | hir::PathResolution::TypeParam(tp) => { | ||
113 | if let Some(subst) = self.substs.get(&tp) { | ||
114 | ted::replace(path.syntax(), subst.clone_subtree().clone_for_update().syntax()) | ||
115 | } | ||
116 | } | ||
117 | hir::PathResolution::Def(def) => { | ||
118 | let found_path = | ||
119 | self.target_module.find_use_path(self.source_scope.db.upcast(), def)?; | ||
120 | let res = mod_path_to_ast(&found_path).clone_for_update(); | ||
121 | if let Some(args) = path.segment().and_then(|it| it.generic_arg_list()) { | ||
122 | if let Some(segment) = res.segment() { | ||
123 | let old = segment.get_or_create_generic_arg_list(); | ||
124 | ted::replace(old.syntax(), args.clone_subtree().syntax().clone_for_update()) | ||
125 | } | ||
126 | } | ||
127 | ted::replace(path.syntax(), res.syntax()) | ||
128 | } | ||
129 | hir::PathResolution::Local(_) | ||
130 | | hir::PathResolution::ConstParam(_) | ||
131 | | hir::PathResolution::SelfType(_) | ||
132 | | hir::PathResolution::Macro(_) | ||
133 | | hir::PathResolution::AssocItem(_) => (), | ||
134 | } | ||
135 | Some(()) | ||
136 | } | ||
137 | } | ||
138 | |||
139 | // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the | ||
140 | // trait ref, and then go from the types in the substs back to the syntax). | ||
141 | fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::Type>> { | ||
142 | let target_trait = impl_def.trait_()?; | ||
143 | let path_type = match target_trait { | ||
144 | ast::Type::PathType(path) => path, | ||
145 | _ => return None, | ||
146 | }; | ||
147 | let generic_arg_list = path_type.path()?.segment()?.generic_arg_list()?; | ||
148 | |||
149 | let mut result = Vec::new(); | ||
150 | for generic_arg in generic_arg_list.generic_args() { | ||
151 | match generic_arg { | ||
152 | ast::GenericArg::TypeArg(type_arg) => result.push(type_arg.ty()?), | ||
153 | ast::GenericArg::AssocTypeArg(_) | ||
154 | | ast::GenericArg::LifetimeArg(_) | ||
155 | | ast::GenericArg::ConstArg(_) => (), | ||
156 | } | ||
157 | } | ||
158 | |||
159 | Some(result) | ||
160 | } | ||
diff --git a/crates/ide_assists/src/utils.rs b/crates/ide_assists/src/utils.rs index 068df005b..0ec236aa0 100644 --- a/crates/ide_assists/src/utils.rs +++ b/crates/ide_assists/src/utils.rs | |||
@@ -8,6 +8,7 @@ use ast::TypeBoundsOwner; | |||
8 | use hir::{Adt, HasSource, Semantics}; | 8 | use hir::{Adt, HasSource, Semantics}; |
9 | use ide_db::{ | 9 | use ide_db::{ |
10 | helpers::{FamousDefs, SnippetCap}, | 10 | helpers::{FamousDefs, SnippetCap}, |
11 | path_transform::PathTransform, | ||
11 | RootDatabase, | 12 | RootDatabase, |
12 | }; | 13 | }; |
13 | use itertools::Itertools; | 14 | use itertools::Itertools; |
@@ -22,10 +23,7 @@ use syntax::{ | |||
22 | SyntaxNode, TextSize, T, | 23 | SyntaxNode, TextSize, T, |
23 | }; | 24 | }; |
24 | 25 | ||
25 | use crate::{ | 26 | use crate::assist_context::{AssistBuilder, AssistContext}; |
26 | assist_context::{AssistBuilder, AssistContext}, | ||
27 | path_transform::PathTransform, | ||
28 | }; | ||
29 | 27 | ||
30 | pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr { | 28 | pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr { |
31 | extract_trivial_expression(&block) | 29 | extract_trivial_expression(&block) |