Merge #2103

2103: Expand signature help r=matklad a=kjeremy

Signature help using call syntax with tuple structs and enum variants

Fixes #2102.

Co-authored-by: Jeremy Kolb <[email protected]>
Co-authored-by: kjeremy <[email protected]>

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
     let name_ref = calling_node.name_ref()?;
 
     let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
-    let function = match &calling_node {
+    let (mut call_info, has_self) = match &calling_node {
         FnCallNode::CallExpr(expr) => {
             //FIXME: apply subst
             let (callable_def, _subst) = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
             match callable_def {
-                hir::CallableDef::Function(it) => it,
-                //FIXME: handle other callables
-                _ => return None,
+                hir::CallableDef::Function(it) => {
+                    (CallInfo::with_fn(db, it), it.data(db).has_self_param())
+                }
+                hir::CallableDef::Struct(it) => (CallInfo::with_struct(db, it)?, false),
+                hir::CallableDef::EnumVariant(it) => (CallInfo::with_enum_variant(db, it)?, false),
             }
         }
-        FnCallNode::MethodCallExpr(expr) => analyzer.resolve_method_call(&expr)?,
+        FnCallNode::MethodCallExpr(expr) => {
+            let function = analyzer.resolve_method_call(&expr)?;
+            (CallInfo::with_fn(db, function), function.data(db).has_self_param())
+        }
     };
 
-    let mut call_info = CallInfo::new(db, function);
-
     // If we have a calling expression let's find which argument we are on
     let num_params = call_info.parameters().len();
-    let has_self = function.data(db).has_self_param();
 
     if num_params == 1 {
         if !has_self {
@@ -115,12 +117,24 @@ impl FnCallNode {
 }
 
 impl CallInfo {
-    fn new(db: &RootDatabase, function: hir::Function) -> Self {
+    fn with_fn(db: &RootDatabase, function: hir::Function) -> Self {
         let signature = FunctionSignature::from_hir(db, function);
 
         CallInfo { signature, active_parameter: None }
     }
 
+    fn with_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
+        let signature = FunctionSignature::from_struct(db, st)?;
+
+        Some(CallInfo { signature, active_parameter: None })
+    }
+
+    fn with_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
+        let signature = FunctionSignature::from_enum_variant(db, variant)?;
+
+        Some(CallInfo { signature, active_parameter: None })
+    }
+
     fn parameters(&self) -> &[String] {
         &self.signature.parameters
     }
@@ -462,4 +476,77 @@ fn main() {
         assert_eq!(info.active_parameter, Some(1));
         assert_eq!(info.label(), "fn bar(&self, _: u32)");
     }
+
+    #[test]
+    fn works_for_tuple_structs() {
+        let info = call_info(
+            r#"
+/// A cool tuple struct
+struct TS(u32, i32);
+fn main() {
+    let s = TS(0, <|>);
+}"#,
+        );
+
+        assert_eq!(info.label(), "struct TS(u32, i32) -> TS");
+        assert_eq!(info.doc().map(|it| it.into()), Some("A cool tuple struct".to_string()));
+        assert_eq!(info.active_parameter, Some(1));
+    }
+
+    #[test]
+    #[should_panic]
+    fn cant_call_named_structs() {
+        let _ = call_info(
+            r#"
+struct TS { x: u32, y: i32 }
+fn main() {
+    let s = TS(<|>);
+}"#,
+        );
+    }
+
+    #[test]
+    fn works_for_enum_variants() {
+        let info = call_info(
+            r#"
+enum E {
+    /// A Variant
+    A(i32),
+    /// Another
+    B,
+    /// And C
+    C { a: i32, b: i32 }
+}
+
+fn main() {
+    let a = E::A(<|>);
+}
+            "#,
+        );
+
+        assert_eq!(info.label(), "E::A(0: i32)");
+        assert_eq!(info.doc().map(|it| it.into()), Some("A Variant".to_string()));
+        assert_eq!(info.active_parameter, Some(0));
+    }
+
+    #[test]
+    #[should_panic]
+    fn cant_call_enum_records() {
+        let _ = call_info(
+            r#"
+enum E {
+    /// A Variant
+    A(i32),
+    /// Another
+    B,
+    /// And C
+    C { a: i32, b: i32 }
+}
+
+fn main() {
+    let a = E::C(<|>);
+}
+            "#,
+        );
+    }
 }