diff options
Diffstat (limited to 'crates/ra_ide_api/src/call_info.rs')
-rw-r--r-- | crates/ra_ide_api/src/call_info.rs | 105 |
1 files changed, 96 insertions, 9 deletions
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs index c95133343..d947ac50c 100644 --- a/crates/ra_ide_api/src/call_info.rs +++ b/crates/ra_ide_api/src/call_info.rs | |||
@@ -20,24 +20,26 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal | |||
20 | let name_ref = calling_node.name_ref()?; | 20 | let name_ref = calling_node.name_ref()?; |
21 | 21 | ||
22 | let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None); | 22 | let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None); |
23 | let function = match &calling_node { | 23 | let (mut call_info, has_self) = match &calling_node { |
24 | FnCallNode::CallExpr(expr) => { | 24 | FnCallNode::CallExpr(expr) => { |
25 | //FIXME: apply subst | 25 | //FIXME: apply subst |
26 | let (callable_def, _subst) = analyzer.type_of(db, &expr.expr()?)?.as_callable()?; | 26 | let (callable_def, _subst) = analyzer.type_of(db, &expr.expr()?)?.as_callable()?; |
27 | match callable_def { | 27 | match callable_def { |
28 | hir::CallableDef::Function(it) => it, | 28 | hir::CallableDef::Function(it) => { |
29 | //FIXME: handle other callables | 29 | (CallInfo::with_fn(db, it), it.data(db).has_self_param()) |
30 | _ => return None, | 30 | } |
31 | hir::CallableDef::Struct(it) => (CallInfo::with_struct(db, it)?, false), | ||
32 | hir::CallableDef::EnumVariant(it) => (CallInfo::with_enum_variant(db, it)?, false), | ||
31 | } | 33 | } |
32 | } | 34 | } |
33 | FnCallNode::MethodCallExpr(expr) => analyzer.resolve_method_call(&expr)?, | 35 | FnCallNode::MethodCallExpr(expr) => { |
36 | let function = analyzer.resolve_method_call(&expr)?; | ||
37 | (CallInfo::with_fn(db, function), function.data(db).has_self_param()) | ||
38 | } | ||
34 | }; | 39 | }; |
35 | 40 | ||
36 | let mut call_info = CallInfo::new(db, function); | ||
37 | |||
38 | // If we have a calling expression let's find which argument we are on | 41 | // If we have a calling expression let's find which argument we are on |
39 | let num_params = call_info.parameters().len(); | 42 | let num_params = call_info.parameters().len(); |
40 | let has_self = function.data(db).has_self_param(); | ||
41 | 43 | ||
42 | if num_params == 1 { | 44 | if num_params == 1 { |
43 | if !has_self { | 45 | if !has_self { |
@@ -115,12 +117,24 @@ impl FnCallNode { | |||
115 | } | 117 | } |
116 | 118 | ||
117 | impl CallInfo { | 119 | impl CallInfo { |
118 | fn new(db: &RootDatabase, function: hir::Function) -> Self { | 120 | fn with_fn(db: &RootDatabase, function: hir::Function) -> Self { |
119 | let signature = FunctionSignature::from_hir(db, function); | 121 | let signature = FunctionSignature::from_hir(db, function); |
120 | 122 | ||
121 | CallInfo { signature, active_parameter: None } | 123 | CallInfo { signature, active_parameter: None } |
122 | } | 124 | } |
123 | 125 | ||
126 | fn with_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> { | ||
127 | let signature = FunctionSignature::from_struct(db, st)?; | ||
128 | |||
129 | Some(CallInfo { signature, active_parameter: None }) | ||
130 | } | ||
131 | |||
132 | fn with_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> { | ||
133 | let signature = FunctionSignature::from_enum_variant(db, variant)?; | ||
134 | |||
135 | Some(CallInfo { signature, active_parameter: None }) | ||
136 | } | ||
137 | |||
124 | fn parameters(&self) -> &[String] { | 138 | fn parameters(&self) -> &[String] { |
125 | &self.signature.parameters | 139 | &self.signature.parameters |
126 | } | 140 | } |
@@ -462,4 +476,77 @@ fn main() { | |||
462 | assert_eq!(info.active_parameter, Some(1)); | 476 | assert_eq!(info.active_parameter, Some(1)); |
463 | assert_eq!(info.label(), "fn bar(&self, _: u32)"); | 477 | assert_eq!(info.label(), "fn bar(&self, _: u32)"); |
464 | } | 478 | } |
479 | |||
480 | #[test] | ||
481 | fn works_for_tuple_structs() { | ||
482 | let info = call_info( | ||
483 | r#" | ||
484 | /// A cool tuple struct | ||
485 | struct TS(u32, i32); | ||
486 | fn main() { | ||
487 | let s = TS(0, <|>); | ||
488 | }"#, | ||
489 | ); | ||
490 | |||
491 | assert_eq!(info.label(), "struct TS(u32, i32) -> TS"); | ||
492 | assert_eq!(info.doc().map(|it| it.into()), Some("A cool tuple struct".to_string())); | ||
493 | assert_eq!(info.active_parameter, Some(1)); | ||
494 | } | ||
495 | |||
496 | #[test] | ||
497 | #[should_panic] | ||
498 | fn cant_call_named_structs() { | ||
499 | let _ = call_info( | ||
500 | r#" | ||
501 | struct TS { x: u32, y: i32 } | ||
502 | fn main() { | ||
503 | let s = TS(<|>); | ||
504 | }"#, | ||
505 | ); | ||
506 | } | ||
507 | |||
508 | #[test] | ||
509 | fn works_for_enum_variants() { | ||
510 | let info = call_info( | ||
511 | r#" | ||
512 | enum E { | ||
513 | /// A Variant | ||
514 | A(i32), | ||
515 | /// Another | ||
516 | B, | ||
517 | /// And C | ||
518 | C { a: i32, b: i32 } | ||
519 | } | ||
520 | |||
521 | fn main() { | ||
522 | let a = E::A(<|>); | ||
523 | } | ||
524 | "#, | ||
525 | ); | ||
526 | |||
527 | assert_eq!(info.label(), "E::A(0: i32)"); | ||
528 | assert_eq!(info.doc().map(|it| it.into()), Some("A Variant".to_string())); | ||
529 | assert_eq!(info.active_parameter, Some(0)); | ||
530 | } | ||
531 | |||
532 | #[test] | ||
533 | #[should_panic] | ||
534 | fn cant_call_enum_records() { | ||
535 | let _ = call_info( | ||
536 | r#" | ||
537 | enum E { | ||
538 | /// A Variant | ||
539 | A(i32), | ||
540 | /// Another | ||
541 | B, | ||
542 | /// And C | ||
543 | C { a: i32, b: i32 } | ||
544 | } | ||
545 | |||
546 | fn main() { | ||
547 | let a = E::C(<|>); | ||
548 | } | ||
549 | "#, | ||
550 | ); | ||
551 | } | ||
465 | } | 552 | } |