Don't ascribe types in pattern completion for patterns twice

Author: Veykril

crates/ide_completion/src/context.rs

@@ -58,6 +58,7 @@ pub(crate) struct PathCompletionContext {
 pub(super) struct PatternContext {
     pub(super) refutability: PatternRefutability,
     pub(super) is_param: Option<ParamKind>,
+    pub(super) has_type_ascription: bool,
 }
 
 #[derive(Debug)]
@@ -708,15 +709,15 @@ impl<'a> CompletionContext<'a> {
             return None;
         }
         let mut is_param = None;
-        let refutability = bind_pat
+        let (refutability, has_type_ascription) = bind_pat
             .syntax()
             .ancestors()
             .skip_while(|it| ast::Pat::can_cast(it.kind()))
             .next()
-            .map_or(PatternRefutability::Irrefutable, |node| {
-                match_ast! {
+            .map_or((PatternRefutability::Irrefutable, false), |node| {
+                let refutability = match_ast! {
                     match node {
-                        ast::LetStmt(__) => PatternRefutability::Irrefutable,
+                        ast::LetStmt(let_) => return (PatternRefutability::Irrefutable, let_.ty().is_some()),
                         ast::Param(param) => {
                             let is_closure_param = param
                                 .syntax()
@@ -729,16 +730,17 @@ impl<'a> CompletionContext<'a> {
                             } else {
                                 ParamKind::Function
                             });
-                            PatternRefutability::Irrefutable
+                            return (PatternRefutability::Irrefutable, param.ty().is_some())
                         },
                         ast::MatchArm(__) => PatternRefutability::Refutable,
                         ast::Condition(__) => PatternRefutability::Refutable,
                         ast::ForExpr(__) => PatternRefutability::Irrefutable,
                         _ => PatternRefutability::Irrefutable,
                     }
-                }
+                };
+                (refutability, false)
             });
-        Some(PatternContext { refutability, is_param })
+        Some(PatternContext { refutability, is_param, has_type_ascription })
     }
 
     fn classify_name_ref(

crates/ide_completion/src/render/pattern.rs

@@ -85,7 +85,11 @@ fn render_pat(
 
     if matches!(
         ctx.completion.pattern_ctx,
-        Some(PatternContext { is_param: Some(ParamKind::Function), .. })
+        Some(PatternContext {
+            is_param: Some(ParamKind::Function),
+            has_type_ascription: false,
+            ..
+        })
     ) {
         pat.push(':');
         pat.push(' ');

crates/ide_completion/src/tests/pattern.rs

@@ -163,6 +163,21 @@ fn foo(a$0) {
             ma makro!(…) #[macro_export] macro_rules! makro
         "##]],
     );
+    check(
+        r#"
+fn foo(a$0: Tuple) {
+}
+"#,
+        expect![[r##"
+            kw mut
+            bn Record    Record { field$1 }$0
+            st Record
+            bn Tuple     Tuple($1)$0
+            st Tuple
+            st Unit
+            ma makro!(…) #[macro_export] macro_rules! makro
+        "##]],
+    );
 }
 
 #[test]