aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--Cargo.lock8
-rw-r--r--crates/hir/src/code_model.rs6
-rw-r--r--crates/hir_def/src/body.rs4
-rw-r--r--crates/hir_def/src/child_by_source.rs4
-rw-r--r--crates/hir_def/src/resolver.rs24
-rw-r--r--crates/ide_assists/src/handlers/generate_default_from_new.rs374
-rw-r--r--crates/ide_assists/src/handlers/generate_function.rs56
-rw-r--r--crates/ide_assists/src/handlers/replace_string_with_char.rs136
-rw-r--r--crates/ide_assists/src/lib.rs2
-rw-r--r--crates/ide_assists/src/tests/generated.rs31
-rw-r--r--crates/proc_macro_srv/src/dylib.rs6
-rw-r--r--crates/proc_macro_srv/src/proc_macro/bridge/client.rs2
-rw-r--r--crates/proc_macro_srv/src/rustc_server.rs141
-rw-r--r--crates/proc_macro_srv/src/tests/utils.rs2
-rw-r--r--crates/rust-analyzer/Cargo.toml2
-rw-r--r--crates/rust-analyzer/src/bin/flags.rs15
-rw-r--r--docs/user/manual.adoc2
-rw-r--r--xtask/Cargo.toml2
-rw-r--r--xtask/src/flags.rs17
19 files changed, 687 insertions, 147 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 39f27098a..c392a8907 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1919,18 +1919,18 @@ checksum = "06069a848f95fceae3e5e03c0ddc8cb78452b56654ee0c8e68f938cf790fb9e3"
1919 1919
1920[[package]] 1920[[package]]
1921name = "xflags" 1921name = "xflags"
1922version = "0.1.4" 1922version = "0.2.1"
1923source = "registry+https://github.com/rust-lang/crates.io-index" 1923source = "registry+https://github.com/rust-lang/crates.io-index"
1924checksum = "222e914b43cec5d7305ac5116d10a14b3a52c50e9062d642c92631f3beabc729" 1924checksum = "59ad6ce6a0b7224130015b4ebac796478ac04e0079f5d222a690efea06a9208a"
1925dependencies = [ 1925dependencies = [
1926 "xflags-macros", 1926 "xflags-macros",
1927] 1927]
1928 1928
1929[[package]] 1929[[package]]
1930name = "xflags-macros" 1930name = "xflags-macros"
1931version = "0.1.4" 1931version = "0.2.1"
1932source = "registry+https://github.com/rust-lang/crates.io-index" 1932source = "registry+https://github.com/rust-lang/crates.io-index"
1933checksum = "52f18f5b4aa7f95e209d5b9274f6164c3938920b4d5c75f97f0dd16daee25ddd" 1933checksum = "c8037d3ca14996158b03c0fa905d0834906ef0fc7044df72c1f5ff690e5e62c9"
1934dependencies = [ 1934dependencies = [
1935 "proc-macro2", 1935 "proc-macro2",
1936] 1936]
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 7656db974..9ee4b3059 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -365,14 +365,14 @@ impl Module {
365 let _p = profile::span("Module::diagnostics").detail(|| { 365 let _p = profile::span("Module::diagnostics").detail(|| {
366 format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string())) 366 format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
367 }); 367 });
368 let crate_def_map = self.id.def_map(db.upcast()); 368 let def_map = self.id.def_map(db.upcast());
369 crate_def_map.add_diagnostics(db.upcast(), self.id.local_id, sink); 369 def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
370 for decl in self.declarations(db) { 370 for decl in self.declarations(db) {
371 match decl { 371 match decl {
372 crate::ModuleDef::Function(f) => f.diagnostics(db, sink), 372 crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
373 crate::ModuleDef::Module(m) => { 373 crate::ModuleDef::Module(m) => {
374 // Only add diagnostics from inline modules 374 // Only add diagnostics from inline modules
375 if crate_def_map[m.id.local_id].origin.is_inline() { 375 if def_map[m.id.local_id].origin.is_inline() {
376 m.diagnostics(db, sink) 376 m.diagnostics(db, sink)
377 } 377 }
378 } 378 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index ff4b4a0cf..16e1bac40 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -87,11 +87,11 @@ impl Expander {
87 module: ModuleId, 87 module: ModuleId,
88 ) -> Expander { 88 ) -> Expander {
89 let cfg_expander = CfgExpander::new(db, current_file_id, module.krate); 89 let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
90 let crate_def_map = module.def_map(db); 90 let def_map = module.def_map(db);
91 let ast_id_map = db.ast_id_map(current_file_id); 91 let ast_id_map = db.ast_id_map(current_file_id);
92 Expander { 92 Expander {
93 cfg_expander, 93 cfg_expander,
94 def_map: crate_def_map, 94 def_map,
95 current_file_id, 95 current_file_id,
96 ast_id_map, 96 ast_id_map,
97 module: module.local_id, 97 module: module.local_id,
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index 65d85c86a..75c2d756b 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -74,8 +74,8 @@ impl ChildBySource for ImplId {
74 74
75impl ChildBySource for ModuleId { 75impl ChildBySource for ModuleId {
76 fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap { 76 fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
77 let crate_def_map = self.def_map(db); 77 let def_map = self.def_map(db);
78 let module_data = &crate_def_map[self.local_id]; 78 let module_data = &def_map[self.local_id];
79 module_data.scope.child_by_source(db) 79 module_data.scope.child_by_source(db)
80 } 80 }
81} 81}
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index e85f85e49..77ff21739 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -34,7 +34,7 @@ pub struct Resolver {
34// FIXME how to store these best 34// FIXME how to store these best
35#[derive(Debug, Clone)] 35#[derive(Debug, Clone)]
36struct ModuleItemMap { 36struct ModuleItemMap {
37 crate_def_map: Arc<DefMap>, 37 def_map: Arc<DefMap>,
38 module_id: LocalModuleId, 38 module_id: LocalModuleId,
39} 39}
40 40
@@ -337,11 +337,11 @@ impl Resolver {
337 let mut traits = FxHashSet::default(); 337 let mut traits = FxHashSet::default();
338 for scope in &self.scopes { 338 for scope in &self.scopes {
339 if let Scope::ModuleScope(m) = scope { 339 if let Scope::ModuleScope(m) = scope {
340 if let Some(prelude) = m.crate_def_map.prelude() { 340 if let Some(prelude) = m.def_map.prelude() {
341 let prelude_def_map = prelude.def_map(db); 341 let prelude_def_map = prelude.def_map(db);
342 traits.extend(prelude_def_map[prelude.local_id].scope.traits()); 342 traits.extend(prelude_def_map[prelude.local_id].scope.traits());
343 } 343 }
344 traits.extend(m.crate_def_map[m.module_id].scope.traits()); 344 traits.extend(m.def_map[m.module_id].scope.traits());
345 } 345 }
346 } 346 }
347 traits 347 traits
@@ -349,7 +349,7 @@ impl Resolver {
349 349
350 fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> { 350 fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> {
351 self.scopes.iter().rev().find_map(|scope| match scope { 351 self.scopes.iter().rev().find_map(|scope| match scope {
352 Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)), 352 Scope::ModuleScope(m) => Some((&*m.def_map, m.module_id)),
353 353
354 _ => None, 354 _ => None,
355 }) 355 })
@@ -413,21 +413,21 @@ impl Scope {
413 // def: m.module.into(), 413 // def: m.module.into(),
414 // }), 414 // }),
415 // ); 415 // );
416 m.crate_def_map[m.module_id].scope.entries().for_each(|(name, def)| { 416 m.def_map[m.module_id].scope.entries().for_each(|(name, def)| {
417 f(name.clone(), ScopeDef::PerNs(def)); 417 f(name.clone(), ScopeDef::PerNs(def));
418 }); 418 });
419 m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| { 419 m.def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
420 let scope = PerNs::macros(macro_, Visibility::Public); 420 let scope = PerNs::macros(macro_, Visibility::Public);
421 seen.insert((name.clone(), scope)); 421 seen.insert((name.clone(), scope));
422 f(name.clone(), ScopeDef::PerNs(scope)); 422 f(name.clone(), ScopeDef::PerNs(scope));
423 }); 423 });
424 m.crate_def_map.extern_prelude().for_each(|(name, &def)| { 424 m.def_map.extern_prelude().for_each(|(name, &def)| {
425 f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public))); 425 f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
426 }); 426 });
427 BUILTIN_SCOPE.iter().for_each(|(name, &def)| { 427 BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
428 f(name.clone(), ScopeDef::PerNs(def)); 428 f(name.clone(), ScopeDef::PerNs(def));
429 }); 429 });
430 if let Some(prelude) = m.crate_def_map.prelude() { 430 if let Some(prelude) = m.def_map.prelude() {
431 let prelude_def_map = prelude.def_map(db); 431 let prelude_def_map = prelude.def_map(db);
432 prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| { 432 prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
433 let seen_tuple = (name.clone(), def); 433 let seen_tuple = (name.clone(), def);
@@ -513,8 +513,8 @@ impl Resolver {
513 self.push_scope(Scope::ImplDefScope(impl_def)) 513 self.push_scope(Scope::ImplDefScope(impl_def))
514 } 514 }
515 515
516 fn push_module_scope(self, crate_def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver { 516 fn push_module_scope(self, def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
517 self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id })) 517 self.push_scope(Scope::ModuleScope(ModuleItemMap { def_map, module_id }))
518 } 518 }
519 519
520 fn push_expr_scope( 520 fn push_expr_scope(
@@ -534,7 +534,7 @@ impl ModuleItemMap {
534 path: &ModPath, 534 path: &ModPath,
535 ) -> Option<ResolveValueResult> { 535 ) -> Option<ResolveValueResult> {
536 let (module_def, idx) = 536 let (module_def, idx) =
537 self.crate_def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other); 537 self.def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
538 match idx { 538 match idx {
539 None => { 539 None => {
540 let value = to_value_ns(module_def)?; 540 let value = to_value_ns(module_def)?;
@@ -564,7 +564,7 @@ impl ModuleItemMap {
564 path: &ModPath, 564 path: &ModPath,
565 ) -> Option<(TypeNs, Option<usize>)> { 565 ) -> Option<(TypeNs, Option<usize>)> {
566 let (module_def, idx) = 566 let (module_def, idx) =
567 self.crate_def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other); 567 self.def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
568 let res = to_type_ns(module_def)?; 568 let res = to_type_ns(module_def)?;
569 Some((res, idx)) 569 Some((res, idx))
570 } 570 }
diff --git a/crates/ide_assists/src/handlers/generate_default_from_new.rs b/crates/ide_assists/src/handlers/generate_default_from_new.rs
new file mode 100644
index 000000000..fa1254579
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_default_from_new.rs
@@ -0,0 +1,374 @@
1use crate::{
2 assist_context::{AssistContext, Assists},
3 AssistId,
4};
5use ide_db::helpers::FamousDefs;
6use syntax::{
7 ast::{self, Impl, NameOwner},
8 AstNode,
9};
10use test_utils::mark;
11
12// Assist: generate_default_from_new
13//
14// Generates default implementation from new method.
15//
16// ```
17// struct Example { _inner: () }
18//
19// impl Example {
20// pub fn n$0ew() -> Self {
21// Self { _inner: () }
22// }
23// }
24// ```
25// ->
26// ```
27// struct Example { _inner: () }
28//
29// impl Example {
30// pub fn new() -> Self {
31// Self { _inner: () }
32// }
33// }
34//
35// impl Default for Example {
36// fn default() -> Self {
37// Self::new()
38// }
39// }
40// ```
41pub(crate) fn generate_default_from_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
42 let fn_node = ctx.find_node_at_offset::<ast::Fn>()?;
43 let fn_name = fn_node.name()?;
44
45 if fn_name.text() != "new" {
46 mark::hit!(other_function_than_new);
47 return None;
48 }
49
50 if fn_node.param_list()?.params().next().is_some() {
51 mark::hit!(new_function_with_parameters);
52 return None;
53 }
54
55 let impl_ = fn_node.syntax().ancestors().into_iter().find_map(ast::Impl::cast)?;
56 if is_default_implemented(ctx, &impl_) {
57 mark::hit!(default_block_is_already_present);
58 mark::hit!(struct_in_module_with_default);
59 return None;
60 }
61
62 let insert_location = impl_.syntax().text_range();
63
64 acc.add(
65 AssistId("generate_default_from_new", crate::AssistKind::Generate),
66 "Generate a Default impl from a new fn",
67 insert_location,
68 move |builder| {
69 let code = default_fn_node_for_new(impl_);
70 builder.insert(insert_location.end(), code);
71 },
72 )
73}
74
75fn default_fn_node_for_new(impl_: Impl) -> String {
76 format!(
77 "
78
79impl Default for {} {{
80 fn default() -> Self {{
81 Self::new()
82 }}
83}}",
84 impl_.self_ty().unwrap().syntax().text()
85 )
86}
87
88fn is_default_implemented(ctx: &AssistContext, impl_: &Impl) -> bool {
89 let db = ctx.sema.db;
90 let impl_ = ctx.sema.to_def(impl_);
91 let impl_def = match impl_ {
92 Some(value) => value,
93 None => return false,
94 };
95
96 let ty = impl_def.target_ty(db);
97 let krate = impl_def.module(db).krate();
98 let default = FamousDefs(&ctx.sema, Some(krate)).core_default_Default();
99 let default_trait = match default {
100 Some(value) => value,
101 None => return false,
102 };
103
104 ty.impls_trait(db, default_trait, &[])
105}
106
107#[cfg(test)]
108mod tests {
109 use ide_db::helpers::FamousDefs;
110
111 use crate::tests::{check_assist, check_assist_not_applicable};
112
113 use super::*;
114
115 #[test]
116 fn generate_default() {
117 check_pass(
118 r#"
119struct Example { _inner: () }
120
121impl Example {
122 pub fn ne$0w() -> Self {
123 Self { _inner: () }
124 }
125}
126
127fn main() {}
128"#,
129 r#"
130struct Example { _inner: () }
131
132impl Example {
133 pub fn new() -> Self {
134 Self { _inner: () }
135 }
136}
137
138impl Default for Example {
139 fn default() -> Self {
140 Self::new()
141 }
142}
143
144fn main() {}
145"#,
146 );
147 }
148
149 #[test]
150 fn generate_default2() {
151 check_pass(
152 r#"
153struct Test { value: u32 }
154
155impl Test {
156 pub fn ne$0w() -> Self {
157 Self { value: 0 }
158 }
159}
160"#,
161 r#"
162struct Test { value: u32 }
163
164impl Test {
165 pub fn new() -> Self {
166 Self { value: 0 }
167 }
168}
169
170impl Default for Test {
171 fn default() -> Self {
172 Self::new()
173 }
174}
175"#,
176 );
177 }
178
179 #[test]
180 fn new_function_with_parameters() {
181 mark::check!(new_function_with_parameters);
182 check_not_applicable(
183 r#"
184struct Example { _inner: () }
185
186impl Example {
187 pub fn $0new(value: ()) -> Self {
188 Self { _inner: value }
189 }
190}
191"#,
192 );
193 }
194
195 #[test]
196 fn other_function_than_new() {
197 mark::check!(other_function_than_new);
198 check_not_applicable(
199 r#"
200struct Example { _inner: () }
201
202impl Example {
203 pub fn a$0dd() -> Self {
204 Self { _inner: () }
205 }
206}
207
208"#,
209 );
210 }
211
212 #[test]
213 fn default_block_is_already_present() {
214 mark::check!(default_block_is_already_present);
215 check_not_applicable(
216 r#"
217struct Example { _inner: () }
218
219impl Example {
220 pub fn n$0ew() -> Self {
221 Self { _inner: () }
222 }
223}
224
225impl Default for Example {
226 fn default() -> Self {
227 Self::new()
228 }
229}
230"#,
231 );
232 }
233
234 #[test]
235 fn standalone_new_function() {
236 check_not_applicable(
237 r#"
238fn n$0ew() -> u32 {
239 0
240}
241"#,
242 );
243 }
244
245 #[test]
246 fn multiple_struct_blocks() {
247 check_pass(
248 r#"
249struct Example { _inner: () }
250struct Test { value: u32 }
251
252impl Example {
253 pub fn new$0() -> Self {
254 Self { _inner: () }
255 }
256}
257"#,
258 r#"
259struct Example { _inner: () }
260struct Test { value: u32 }
261
262impl Example {
263 pub fn new() -> Self {
264 Self { _inner: () }
265 }
266}
267
268impl Default for Example {
269 fn default() -> Self {
270 Self::new()
271 }
272}
273"#,
274 );
275 }
276
277 #[test]
278 fn when_struct_is_after_impl() {
279 check_pass(
280 r#"
281impl Example {
282 pub fn $0new() -> Self {
283 Self { _inner: () }
284 }
285}
286
287struct Example { _inner: () }
288"#,
289 r#"
290impl Example {
291 pub fn new() -> Self {
292 Self { _inner: () }
293 }
294}
295
296impl Default for Example {
297 fn default() -> Self {
298 Self::new()
299 }
300}
301
302struct Example { _inner: () }
303"#,
304 );
305 }
306
307 #[test]
308 fn struct_in_module() {
309 check_pass(
310 r#"
311mod test {
312 struct Example { _inner: () }
313
314 impl Example {
315 pub fn n$0ew() -> Self {
316 Self { _inner: () }
317 }
318 }
319}
320"#,
321 r#"
322mod test {
323 struct Example { _inner: () }
324
325 impl Example {
326 pub fn new() -> Self {
327 Self { _inner: () }
328 }
329 }
330
331impl Default for Example {
332 fn default() -> Self {
333 Self::new()
334 }
335}
336}
337"#,
338 );
339 }
340
341 #[test]
342 fn struct_in_module_with_default() {
343 mark::check!(struct_in_module_with_default);
344 check_not_applicable(
345 r#"
346mod test {
347 struct Example { _inner: () }
348
349 impl Example {
350 pub fn n$0ew() -> Self {
351 Self { _inner: () }
352 }
353 }
354
355 impl Default for Example {
356 fn default() -> Self {
357 Self::new()
358 }
359 }
360}
361"#,
362 );
363 }
364
365 fn check_pass(before: &str, after: &str) {
366 let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
367 check_assist(generate_default_from_new, before, after);
368 }
369
370 fn check_not_applicable(before: &str) {
371 let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
372 check_assist_not_applicable(generate_default_from_new, before);
373 }
374}
diff --git a/crates/ide_assists/src/handlers/generate_function.rs b/crates/ide_assists/src/handlers/generate_function.rs
index 959824981..3870b7e75 100644
--- a/crates/ide_assists/src/handlers/generate_function.rs
+++ b/crates/ide_assists/src/handlers/generate_function.rs
@@ -1,6 +1,7 @@
1use hir::HirDisplay; 1use hir::HirDisplay;
2use ide_db::{base_db::FileId, helpers::SnippetCap}; 2use ide_db::{base_db::FileId, helpers::SnippetCap};
3use rustc_hash::{FxHashMap, FxHashSet}; 3use rustc_hash::{FxHashMap, FxHashSet};
4use stdx::to_lower_snake_case;
4use syntax::{ 5use syntax::{
5 ast::{ 6 ast::{
6 self, 7 self,
@@ -257,14 +258,15 @@ fn deduplicate_arg_names(arg_names: &mut Vec<String>) {
257fn fn_arg_name(fn_arg: &ast::Expr) -> Option<String> { 258fn fn_arg_name(fn_arg: &ast::Expr) -> Option<String> {
258 match fn_arg { 259 match fn_arg {
259 ast::Expr::CastExpr(cast_expr) => fn_arg_name(&cast_expr.expr()?), 260 ast::Expr::CastExpr(cast_expr) => fn_arg_name(&cast_expr.expr()?),
260 _ => Some( 261 _ => {
261 fn_arg 262 let s = fn_arg
262 .syntax() 263 .syntax()
263 .descendants() 264 .descendants()
264 .filter(|d| ast::NameRef::can_cast(d.kind())) 265 .filter(|d| ast::NameRef::can_cast(d.kind()))
265 .last()? 266 .last()?
266 .to_string(), 267 .to_string();
267 ), 268 Some(to_lower_snake_case(&s))
269 }
268 } 270 }
269} 271}
270 272
@@ -448,6 +450,52 @@ mod baz {
448 } 450 }
449 451
450 #[test] 452 #[test]
453 fn add_function_with_upper_camel_case_arg() {
454 check_assist(
455 generate_function,
456 r"
457struct BazBaz;
458fn foo() {
459 bar$0(BazBaz);
460}
461",
462 r"
463struct BazBaz;
464fn foo() {
465 bar(BazBaz);
466}
467
468fn bar(baz_baz: BazBaz) ${0:-> ()} {
469 todo!()
470}
471",
472 );
473 }
474
475 #[test]
476 fn add_function_with_upper_camel_case_arg_as_cast() {
477 check_assist(
478 generate_function,
479 r"
480struct BazBaz;
481fn foo() {
482 bar$0(&BazBaz as *const BazBaz);
483}
484",
485 r"
486struct BazBaz;
487fn foo() {
488 bar(&BazBaz as *const BazBaz);
489}
490
491fn bar(baz_baz: *const BazBaz) ${0:-> ()} {
492 todo!()
493}
494",
495 );
496 }
497
498 #[test]
451 fn add_function_with_function_call_arg() { 499 fn add_function_with_function_call_arg() {
452 check_assist( 500 check_assist(
453 generate_function, 501 generate_function,
diff --git a/crates/ide_assists/src/handlers/replace_string_with_char.rs b/crates/ide_assists/src/handlers/replace_string_with_char.rs
index 317318c24..634b9c0b7 100644
--- a/crates/ide_assists/src/handlers/replace_string_with_char.rs
+++ b/crates/ide_assists/src/handlers/replace_string_with_char.rs
@@ -25,13 +25,16 @@ pub(crate) fn replace_string_with_char(acc: &mut Assists, ctx: &AssistContext) -
25 if value.chars().take(2).count() != 1 { 25 if value.chars().take(2).count() != 1 {
26 return None; 26 return None;
27 } 27 }
28 let quote_offets = token.quote_offsets()?;
28 29
29 acc.add( 30 acc.add(
30 AssistId("replace_string_with_char", AssistKind::RefactorRewrite), 31 AssistId("replace_string_with_char", AssistKind::RefactorRewrite),
31 "Replace string with char", 32 "Replace string with char",
32 target, 33 target,
33 |edit| { 34 |edit| {
34 edit.replace(token.syntax().text_range(), format!("'{}'", value)); 35 let (left, right) = quote_offets.quotes;
36 edit.replace(left, String::from('\''));
37 edit.replace(right, String::from('\''));
35 }, 38 },
36 ) 39 )
37} 40}
@@ -47,10 +50,10 @@ mod tests {
47 check_assist_target( 50 check_assist_target(
48 replace_string_with_char, 51 replace_string_with_char,
49 r#" 52 r#"
50 fn f() { 53fn f() {
51 let s = "$0c"; 54 let s = "$0c";
52 } 55}
53 "#, 56"#,
54 r#""c""#, 57 r#""c""#,
55 ); 58 );
56 } 59 }
@@ -60,15 +63,15 @@ mod tests {
60 check_assist( 63 check_assist(
61 replace_string_with_char, 64 replace_string_with_char,
62 r#" 65 r#"
63 fn f() { 66fn f() {
64 let s = "$0c"; 67 let s = "$0c";
65 } 68}
66 "#, 69"#,
67 r##" 70 r##"
68 fn f() { 71fn f() {
69 let s = 'c'; 72 let s = 'c';
70 } 73}
71 "##, 74"##,
72 ) 75 )
73 } 76 }
74 77
@@ -77,15 +80,15 @@ mod tests {
77 check_assist( 80 check_assist(
78 replace_string_with_char, 81 replace_string_with_char,
79 r#" 82 r#"
80 fn f() { 83fn f() {
81 let s = "$0😀"; 84 let s = "$0😀";
82 } 85}
83 "#, 86"#,
84 r##" 87 r##"
85 fn f() { 88fn f() {
86 let s = '😀'; 89 let s = '😀';
87 } 90}
88 "##, 91"##,
89 ) 92 )
90 } 93 }
91 94
@@ -94,10 +97,10 @@ mod tests {
94 check_assist_not_applicable( 97 check_assist_not_applicable(
95 replace_string_with_char, 98 replace_string_with_char,
96 r#" 99 r#"
97 fn f() { 100fn f() {
98 let s = "$0test"; 101 let s = "$0test";
99 } 102}
100 "#, 103"#,
101 ) 104 )
102 } 105 }
103 106
@@ -106,15 +109,15 @@ mod tests {
106 check_assist( 109 check_assist(
107 replace_string_with_char, 110 replace_string_with_char,
108 r#" 111 r#"
109 fn f() { 112fn f() {
110 format!($0"x", 92) 113 format!($0"x", 92)
111 } 114}
112 "#, 115"#,
113 r##" 116 r##"
114 fn f() { 117fn f() {
115 format!('x', 92) 118 format!('x', 92)
116 } 119}
117 "##, 120"##,
118 ) 121 )
119 } 122 }
120 123
@@ -123,15 +126,66 @@ mod tests {
123 check_assist( 126 check_assist(
124 replace_string_with_char, 127 replace_string_with_char,
125 r#" 128 r#"
126 fn f() { 129fn f() {
127 find($0"x"); 130 find($0"x");
128 } 131}
129 "#, 132"#,
130 r##" 133 r##"
131 fn f() { 134fn f() {
132 find('x'); 135 find('x');
133 } 136}
134 "##, 137"##,
138 )
139 }
140
141 #[test]
142 fn replace_string_with_char_newline() {
143 check_assist(
144 replace_string_with_char,
145 r#"
146fn f() {
147 find($0"\n");
148}
149"#,
150 r##"
151fn f() {
152 find('\n');
153}
154"##,
155 )
156 }
157
158 #[test]
159 fn replace_string_with_char_unicode_escape() {
160 check_assist(
161 replace_string_with_char,
162 r#"
163fn f() {
164 find($0"\u{7FFF}");
165}
166"#,
167 r##"
168fn f() {
169 find('\u{7FFF}');
170}
171"##,
172 )
173 }
174
175 #[test]
176 fn replace_raw_string_with_char() {
177 check_assist(
178 replace_string_with_char,
179 r##"
180fn f() {
181 $0r#"X"#
182}
183"##,
184 r##"
185fn f() {
186 'X'
187}
188"##,
135 ) 189 )
136 } 190 }
137} 191}
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 9c8148462..ea62d5f5d 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -127,6 +127,7 @@ mod handlers {
127 mod flip_comma; 127 mod flip_comma;
128 mod flip_trait_bound; 128 mod flip_trait_bound;
129 mod generate_default_from_enum_variant; 129 mod generate_default_from_enum_variant;
130 mod generate_default_from_new;
130 mod generate_derive; 131 mod generate_derive;
131 mod generate_enum_is_method; 132 mod generate_enum_is_method;
132 mod generate_enum_projection_method; 133 mod generate_enum_projection_method;
@@ -189,6 +190,7 @@ mod handlers {
189 flip_comma::flip_comma, 190 flip_comma::flip_comma,
190 flip_trait_bound::flip_trait_bound, 191 flip_trait_bound::flip_trait_bound,
191 generate_default_from_enum_variant::generate_default_from_enum_variant, 192 generate_default_from_enum_variant::generate_default_from_enum_variant,
193 generate_default_from_new::generate_default_from_new,
192 generate_derive::generate_derive, 194 generate_derive::generate_derive,
193 generate_enum_is_method::generate_enum_is_method, 195 generate_enum_is_method::generate_enum_is_method,
194 generate_enum_projection_method::generate_enum_as_method, 196 generate_enum_projection_method::generate_enum_as_method,
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 4f007aa48..304b5798f 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -440,6 +440,37 @@ impl Default for Version {
440} 440}
441 441
442#[test] 442#[test]
443fn doctest_generate_default_from_new() {
444 check_doc_test(
445 "generate_default_from_new",
446 r#####"
447struct Example { _inner: () }
448
449impl Example {
450 pub fn n$0ew() -> Self {
451 Self { _inner: () }
452 }
453}
454"#####,
455 r#####"
456struct Example { _inner: () }
457
458impl Example {
459 pub fn new() -> Self {
460 Self { _inner: () }
461 }
462}
463
464impl Default for Example {
465 fn default() -> Self {
466 Self::new()
467 }
468}
469"#####,
470 )
471}
472
473#[test]
443fn doctest_generate_derive() { 474fn doctest_generate_derive() {
444 check_doc_test( 475 check_doc_test(
445 "generate_derive", 476 "generate_derive",
diff --git a/crates/proc_macro_srv/src/dylib.rs b/crates/proc_macro_srv/src/dylib.rs
index 28a6ee547..baf10fea9 100644
--- a/crates/proc_macro_srv/src/dylib.rs
+++ b/crates/proc_macro_srv/src/dylib.rs
@@ -138,7 +138,7 @@ impl Expander {
138 parsed_body, 138 parsed_body,
139 false, 139 false,
140 ); 140 );
141 return res.map(|it| it.subtree); 141 return res.map(|it| it.into_subtree());
142 } 142 }
143 bridge::client::ProcMacro::Bang { name, client } if *name == macro_name => { 143 bridge::client::ProcMacro::Bang { name, client } if *name == macro_name => {
144 let res = client.run( 144 let res = client.run(
@@ -147,7 +147,7 @@ impl Expander {
147 parsed_body, 147 parsed_body,
148 false, 148 false,
149 ); 149 );
150 return res.map(|it| it.subtree); 150 return res.map(|it| it.into_subtree());
151 } 151 }
152 bridge::client::ProcMacro::Attr { name, client } if *name == macro_name => { 152 bridge::client::ProcMacro::Attr { name, client } if *name == macro_name => {
153 let res = client.run( 153 let res = client.run(
@@ -157,7 +157,7 @@ impl Expander {
157 parsed_body, 157 parsed_body,
158 false, 158 false,
159 ); 159 );
160 return res.map(|it| it.subtree); 160 return res.map(|it| it.into_subtree());
161 } 161 }
162 _ => continue, 162 _ => continue,
163 } 163 }
diff --git a/crates/proc_macro_srv/src/proc_macro/bridge/client.rs b/crates/proc_macro_srv/src/proc_macro/bridge/client.rs
index ca6749b9b..b036d4e20 100644
--- a/crates/proc_macro_srv/src/proc_macro/bridge/client.rs
+++ b/crates/proc_macro_srv/src/proc_macro/bridge/client.rs
@@ -238,7 +238,7 @@ macro_rules! define_client_side {
238 $(impl $name { 238 $(impl $name {
239 #[allow(unused)] 239 #[allow(unused)]
240 $(pub(crate) fn $method($($arg: $arg_ty),*) $(-> $ret_ty)* { 240 $(pub(crate) fn $method($($arg: $arg_ty),*) $(-> $ret_ty)* {
241 panic!("hello"); 241 panic!("crates should be linked against the sysroot version of proc_macro, not this one from rust-analyzer");
242 // Bridge::with(|bridge| { 242 // Bridge::with(|bridge| {
243 // let mut b = bridge.cached_buffer.take(); 243 // let mut b = bridge.cached_buffer.take();
244 244
diff --git a/crates/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index 14c853c77..ceefd187d 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -25,27 +25,35 @@ type Span = tt::TokenId;
25 25
26#[derive(Debug, Clone)] 26#[derive(Debug, Clone)]
27pub struct TokenStream { 27pub struct TokenStream {
28 pub subtree: tt::Subtree, 28 pub token_trees: Vec<TokenTree>,
29} 29}
30 30
31impl TokenStream { 31impl TokenStream {
32 pub fn new() -> Self { 32 pub fn new() -> Self {
33 TokenStream { subtree: Default::default() } 33 TokenStream { token_trees: Default::default() }
34 } 34 }
35 35
36 pub fn with_subtree(subtree: tt::Subtree) -> Self { 36 pub fn with_subtree(subtree: tt::Subtree) -> Self {
37 TokenStream { subtree } 37 if subtree.delimiter.is_some() {
38 TokenStream { token_trees: vec![TokenTree::Subtree(subtree)] }
39 } else {
40 TokenStream { token_trees: subtree.token_trees }
41 }
42 }
43
44 pub fn into_subtree(self) -> tt::Subtree {
45 tt::Subtree { delimiter: None, token_trees: self.token_trees }
38 } 46 }
39 47
40 pub fn is_empty(&self) -> bool { 48 pub fn is_empty(&self) -> bool {
41 self.subtree.token_trees.is_empty() 49 self.token_trees.is_empty()
42 } 50 }
43} 51}
44 52
45/// Creates a token stream containing a single token tree. 53/// Creates a token stream containing a single token tree.
46impl From<TokenTree> for TokenStream { 54impl From<TokenTree> for TokenStream {
47 fn from(tree: TokenTree) -> TokenStream { 55 fn from(tree: TokenTree) -> TokenStream {
48 TokenStream { subtree: tt::Subtree { delimiter: None, token_trees: vec![tree] } } 56 TokenStream { token_trees: vec![tree] }
49 } 57 }
50} 58}
51 59
@@ -78,10 +86,10 @@ impl Extend<TokenStream> for TokenStream {
78 for tkn in item { 86 for tkn in item {
79 match tkn { 87 match tkn {
80 tt::TokenTree::Subtree(subtree) if subtree.delimiter.is_none() => { 88 tt::TokenTree::Subtree(subtree) if subtree.delimiter.is_none() => {
81 self.subtree.token_trees.extend(subtree.token_trees); 89 self.token_trees.extend(subtree.token_trees);
82 } 90 }
83 _ => { 91 _ => {
84 self.subtree.token_trees.push(tkn); 92 self.token_trees.push(tkn);
85 } 93 }
86 } 94 }
87 } 95 }
@@ -164,7 +172,7 @@ pub mod token_stream {
164 type IntoIter = super::IntoIter<TokenTree>; 172 type IntoIter = super::IntoIter<TokenTree>;
165 173
166 fn into_iter(self) -> Self::IntoIter { 174 fn into_iter(self) -> Self::IntoIter {
167 self.subtree.token_trees.into_iter() 175 self.token_trees.into_iter()
168 } 176 }
169 } 177 }
170 178
@@ -185,28 +193,22 @@ pub mod token_stream {
185 mbe::parse_to_token_tree(src).ok_or("Failed to parse from mbe")?; 193 mbe::parse_to_token_tree(src).ok_or("Failed to parse from mbe")?;
186 194
187 let subtree = subtree_replace_token_ids_with_unspecified(subtree); 195 let subtree = subtree_replace_token_ids_with_unspecified(subtree);
188 Ok(TokenStream { subtree }) 196 Ok(TokenStream::with_subtree(subtree))
189 } 197 }
190 } 198 }
191 199
192 impl ToString for TokenStream { 200 impl ToString for TokenStream {
193 fn to_string(&self) -> String { 201 fn to_string(&self) -> String {
194 let tt = self.subtree.clone().into(); 202 return tokentrees_to_text(&self.token_trees[..]);
195 to_text(&tt)
196 }
197 }
198 203
199 fn to_text(tkn: &tt::TokenTree) -> String { 204 fn tokentrees_to_text(tkns: &[tt::TokenTree]) -> String {
200 match tkn { 205 tkns.iter()
201 tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => ident.text.clone().into(),
202 tt::TokenTree::Leaf(tt::Leaf::Literal(literal)) => literal.text.clone().into(),
203 tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) => format!("{}", punct.char),
204 tt::TokenTree::Subtree(subtree) => {
205 let content = subtree
206 .token_trees
207 .iter()
208 .fold((String::new(), true), |(last, last_to_joint), tkn| { 206 .fold((String::new(), true), |(last, last_to_joint), tkn| {
209 let s = [last, to_text(tkn)].join(if last_to_joint { "" } else { " " }); 207 let s = [last, tokentree_to_text(tkn)].join(if last_to_joint {
208 ""
209 } else {
210 " "
211 });
210 let mut is_joint = false; 212 let mut is_joint = false;
211 if let tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) = tkn { 213 if let tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) = tkn {
212 if punct.spacing == tt::Spacing::Joint { 214 if punct.spacing == tt::Spacing::Joint {
@@ -215,15 +217,25 @@ pub mod token_stream {
215 } 217 }
216 (s, is_joint) 218 (s, is_joint)
217 }) 219 })
218 .0; 220 .0
219 221 }
220 let (open, close) = match subtree.delimiter.map(|it| it.kind) { 222
221 None => ("", ""), 223 fn tokentree_to_text(tkn: &tt::TokenTree) -> String {
222 Some(tt::DelimiterKind::Brace) => ("{", "}"), 224 match tkn {
223 Some(tt::DelimiterKind::Parenthesis) => ("(", ")"), 225 tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => ident.text.clone().into(),
224 Some(tt::DelimiterKind::Bracket) => ("[", "]"), 226 tt::TokenTree::Leaf(tt::Leaf::Literal(literal)) => literal.text.clone().into(),
225 }; 227 tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) => format!("{}", punct.char),
226 format!("{}{}{}", open, content, close) 228 tt::TokenTree::Subtree(subtree) => {
229 let content = tokentrees_to_text(&subtree.token_trees);
230 let (open, close) = match subtree.delimiter.map(|it| it.kind) {
231 None => ("", ""),
232 Some(tt::DelimiterKind::Brace) => ("{", "}"),
233 Some(tt::DelimiterKind::Parenthesis) => ("(", ")"),
234 Some(tt::DelimiterKind::Bracket) => ("[", "]"),
235 };
236 format!("{}{}{}", open, content, close)
237 }
238 }
227 } 239 }
228 } 240 }
229 } 241 }
@@ -433,10 +445,7 @@ fn spacing_to_external(spacing: Spacing) -> bridge::Spacing {
433 445
434impl server::Group for Rustc { 446impl server::Group for Rustc {
435 fn new(&mut self, delimiter: bridge::Delimiter, stream: Self::TokenStream) -> Self::Group { 447 fn new(&mut self, delimiter: bridge::Delimiter, stream: Self::TokenStream) -> Self::Group {
436 Self::Group { 448 Self::Group { delimiter: delim_to_internal(delimiter), token_trees: stream.token_trees }
437 delimiter: delim_to_internal(delimiter),
438 token_trees: stream.subtree.token_trees,
439 }
440 } 449 }
441 fn delimiter(&mut self, group: &Self::Group) -> bridge::Delimiter { 450 fn delimiter(&mut self, group: &Self::Group) -> bridge::Delimiter {
442 delim_to_external(group.delimiter) 451 delim_to_external(group.delimiter)
@@ -444,9 +453,7 @@ impl server::Group for Rustc {
444 453
445 // NOTE: Return value of do not include delimiter 454 // NOTE: Return value of do not include delimiter
446 fn stream(&mut self, group: &Self::Group) -> Self::TokenStream { 455 fn stream(&mut self, group: &Self::Group) -> Self::TokenStream {
447 TokenStream { 456 TokenStream { token_trees: group.token_trees.clone() }
448 subtree: tt::Subtree { delimiter: None, token_trees: group.token_trees.clone() },
449 }
450 } 457 }
451 458
452 fn span(&mut self, group: &Self::Group) -> Self::Span { 459 fn span(&mut self, group: &Self::Group) -> Self::Span {
@@ -755,28 +762,48 @@ mod tests {
755 #[test] 762 #[test]
756 fn test_rustc_server_to_string() { 763 fn test_rustc_server_to_string() {
757 let s = TokenStream { 764 let s = TokenStream {
758 subtree: tt::Subtree { 765 token_trees: vec![
759 delimiter: None, 766 tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
760 token_trees: vec![ 767 text: "struct".into(),
761 tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident { 768 id: tt::TokenId::unspecified(),
762 text: "struct".into(), 769 })),
763 id: tt::TokenId::unspecified(), 770 tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
764 })), 771 text: "T".into(),
765 tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident { 772 id: tt::TokenId::unspecified(),
766 text: "T".into(), 773 })),
774 tt::TokenTree::Subtree(tt::Subtree {
775 delimiter: Some(tt::Delimiter {
767 id: tt::TokenId::unspecified(), 776 id: tt::TokenId::unspecified(),
768 })), 777 kind: tt::DelimiterKind::Brace,
769 tt::TokenTree::Subtree(tt::Subtree {
770 delimiter: Some(tt::Delimiter {
771 id: tt::TokenId::unspecified(),
772 kind: tt::DelimiterKind::Brace,
773 }),
774 token_trees: vec![],
775 }), 778 }),
776 ], 779 token_trees: vec![],
777 }, 780 }),
781 ],
778 }; 782 };
779 783
780 assert_eq!(s.to_string(), "struct T {}"); 784 assert_eq!(s.to_string(), "struct T {}");
781 } 785 }
786
787 #[test]
788 fn test_rustc_server_from_str() {
789 use std::str::FromStr;
790 let subtree_paren_a = tt::TokenTree::Subtree(tt::Subtree {
791 delimiter: Some(tt::Delimiter {
792 id: tt::TokenId::unspecified(),
793 kind: tt::DelimiterKind::Parenthesis,
794 }),
795 token_trees: vec![tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
796 text: "a".into(),
797 id: tt::TokenId::unspecified(),
798 }))],
799 });
800
801 let t1 = TokenStream::from_str("(a)").unwrap();
802 assert_eq!(t1.token_trees.len(), 1);
803 assert_eq!(t1.token_trees[0], subtree_paren_a);
804
805 let t2 = TokenStream::from_str("(a);").unwrap();
806 assert_eq!(t2.token_trees.len(), 2);
807 assert_eq!(t2.token_trees[0], subtree_paren_a);
808 }
782} 809}
diff --git a/crates/proc_macro_srv/src/tests/utils.rs b/crates/proc_macro_srv/src/tests/utils.rs
index 22813052d..0484c3af4 100644
--- a/crates/proc_macro_srv/src/tests/utils.rs
+++ b/crates/proc_macro_srv/src/tests/utils.rs
@@ -52,7 +52,7 @@ pub fn assert_expand(
52 let expander = dylib::Expander::new(&path).unwrap(); 52 let expander = dylib::Expander::new(&path).unwrap();
53 let fixture = parse_string(ra_fixture).unwrap(); 53 let fixture = parse_string(ra_fixture).unwrap();
54 54
55 let res = expander.expand(macro_name, &fixture.subtree, None).unwrap(); 55 let res = expander.expand(macro_name, &fixture.into_subtree(), None).unwrap();
56 assert_eq_text!(&expect.trim(), &format!("{:?}", res)); 56 assert_eq_text!(&expect.trim(), &format!("{:?}", res));
57} 57}
58 58
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 8789f0852..3130785cc 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -24,7 +24,7 @@ jod-thread = "0.1.0"
24log = "0.4.8" 24log = "0.4.8"
25lsp-types = { version = "0.88.0", features = ["proposed"] } 25lsp-types = { version = "0.88.0", features = ["proposed"] }
26parking_lot = "0.11.0" 26parking_lot = "0.11.0"
27xflags = "0.1.2" 27xflags = "0.2.1"
28oorandom = "11.1.2" 28oorandom = "11.1.2"
29rustc-hash = "1.1.0" 29rustc-hash = "1.1.0"
30serde = { version = "1.0.106", features = ["derive"] } 30serde = { version = "1.0.106", features = ["derive"] }
diff --git a/crates/rust-analyzer/src/bin/flags.rs b/crates/rust-analyzer/src/bin/flags.rs
index 244912d26..3a7caaf3f 100644
--- a/crates/rust-analyzer/src/bin/flags.rs
+++ b/crates/rust-analyzer/src/bin/flags.rs
@@ -6,7 +6,9 @@ use ide_ssr::{SsrPattern, SsrRule};
6use rust_analyzer::cli::{BenchWhat, Position, Verbosity}; 6use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
7use vfs::AbsPathBuf; 7use vfs::AbsPathBuf;
8 8
9xflags::args_parser! { 9xflags::xflags! {
10 src "./src/bin/flags.rs"
11
10 /// LSP server for the Rust programming language. 12 /// LSP server for the Rust programming language.
11 cmd rust-analyzer { 13 cmd rust-analyzer {
12 /// Verbosity level, can be repeated multiple times. 14 /// Verbosity level, can be repeated multiple times.
@@ -120,7 +122,7 @@ xflags::args_parser! {
120 122
121// generated start 123// generated start
122// The following code is generated by `xflags` macro. 124// The following code is generated by `xflags` macro.
123// Run `env XFLAGS_DUMP= cargo build` to regenerate. 125// Run `env UPDATE_XFLAGS=1 cargo build` to regenerate.
124#[derive(Debug)] 126#[derive(Debug)]
125pub struct RustAnalyzer { 127pub struct RustAnalyzer {
126 pub verbose: u32, 128 pub verbose: u32,
@@ -158,7 +160,7 @@ pub struct Parse {
158} 160}
159 161
160#[derive(Debug)] 162#[derive(Debug)]
161pub struct Symbols {} 163pub struct Symbols;
162 164
163#[derive(Debug)] 165#[derive(Debug)]
164pub struct Highlight { 166pub struct Highlight {
@@ -211,14 +213,13 @@ pub struct Search {
211} 213}
212 214
213#[derive(Debug)] 215#[derive(Debug)]
214pub struct ProcMacro {} 216pub struct ProcMacro;
215 217
216impl RustAnalyzer { 218impl RustAnalyzer {
217 pub const HELP: &'static str = Self::_HELP; 219 pub const HELP: &'static str = Self::HELP_;
218 220
219 pub fn from_env() -> xflags::Result<Self> { 221 pub fn from_env() -> xflags::Result<Self> {
220 let mut p = xflags::rt::Parser::new_from_env(); 222 Self::from_env_()
221 Self::_parse(&mut p)
222 } 223 }
223} 224}
224// generated end 225// generated end
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 9f28237ff..4f2217546 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -226,6 +226,8 @@ The are several LSP client implementations for vim or neovim:
226 * inlay hints for variables and method chaining, _Neovim Only_ 226 * inlay hints for variables and method chaining, _Neovim Only_
227 * semantic highlighting is not implemented yet 227 * semantic highlighting is not implemented yet
228 228
229Note: for code actions, use `coc-codeaction-cursor` and `coc-codeaction-selected`; `coc-codeaction` and `coc-codeaction-line` are unlikely to be useful.
230
229==== LanguageClient-neovim 231==== LanguageClient-neovim
230 232
2311. Install LanguageClient-neovim by following the instructions 2331. Install LanguageClient-neovim by following the instructions
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index b17dde598..e084f0df6 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -15,5 +15,5 @@ ungrammar = "=1.11"
15walkdir = "2.3.1" 15walkdir = "2.3.1"
16write-json = "0.1.0" 16write-json = "0.1.0"
17xshell = "0.1" 17xshell = "0.1"
18xflags = "0.1.2" 18xflags = "0.2.1"
19# Avoid adding more dependencies to this crate 19# Avoid adding more dependencies to this crate
diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs
index 56eda5b1e..b39d937ca 100644
--- a/xtask/src/flags.rs
+++ b/xtask/src/flags.rs
@@ -2,7 +2,9 @@
2 2
3use crate::install::{ClientOpt, Malloc, ServerOpt}; 3use crate::install::{ClientOpt, Malloc, ServerOpt};
4 4
5xflags::args_parser! { 5xflags::xflags! {
6 src "./src/flags.rs"
7
6 /// Run custom build command. 8 /// Run custom build command.
7 cmd xtask { 9 cmd xtask {
8 default cmd help { 10 default cmd help {
@@ -55,7 +57,7 @@ xflags::args_parser! {
55 57
56// generated start 58// generated start
57// The following code is generated by `xflags` macro. 59// The following code is generated by `xflags` macro.
58// Run `env XFLAGS_DUMP= cargo build` to regenerate. 60// Run `env UPDATE_XFLAGS=1 cargo build` to regenerate.
59#[derive(Debug)] 61#[derive(Debug)]
60pub struct Xtask { 62pub struct Xtask {
61 pub subcommand: XtaskCmd, 63 pub subcommand: XtaskCmd,
@@ -96,13 +98,13 @@ pub struct Codegen {
96} 98}
97 99
98#[derive(Debug)] 100#[derive(Debug)]
99pub struct Lint {} 101pub struct Lint;
100 102
101#[derive(Debug)] 103#[derive(Debug)]
102pub struct FuzzTests {} 104pub struct FuzzTests;
103 105
104#[derive(Debug)] 106#[derive(Debug)]
105pub struct PreCache {} 107pub struct PreCache;
106 108
107#[derive(Debug)] 109#[derive(Debug)]
108pub struct Release { 110pub struct Release {
@@ -131,11 +133,10 @@ pub struct Bb {
131} 133}
132 134
133impl Xtask { 135impl Xtask {
134 pub const HELP: &'static str = Self::_HELP; 136 pub const HELP: &'static str = Self::HELP_;
135 137
136 pub fn from_env() -> xflags::Result<Self> { 138 pub fn from_env() -> xflags::Result<Self> {
137 let mut p = xflags::rt::Parser::new_from_env(); 139 Self::from_env_()
138 Self::_parse(&mut p)
139 } 140 }
140} 141}
141// generated end 142// generated end