pub(super) struct PatternContext {
pub(super) refutability: PatternRefutability,
pub(super) is_param: Option<ParamKind>,
+ pub(super) has_type_ascription: bool,
}
#[derive(Debug)]
// check kind of macro-expanded token, but use range of original token
let kind = self.token.kind();
if kind == IDENT || kind == LIFETIME_IDENT || kind == UNDERSCORE || kind.is_keyword() {
- cov_mark::hit!(completes_if_prefix_is_keyword);
self.original_token.text_range()
} else if kind == CHAR {
// assume we are completing a lifetime but the user has only typed the '
.map(|c| (Some(c.return_type()), None))
.unwrap_or((None, None))
},
- ast::Stmt(_it) => (None, None),
+ ast::ParamList(__) => (None, None),
+ ast::Stmt(__) => (None, None),
ast::Item(__) => (None, None),
_ => {
match node.parent() {
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()
} 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(
expect![[r#"ty: Foo, name: ?"#]],
);
}
+
+ #[test]
+ fn expected_type_param_pat() {
+ check_expected_type_and_name(
+ r#"
+struct Foo { field: u32 }
+fn foo(a$0: Foo) {}
+"#,
+ expect![[r#"ty: Foo, name: ?"#]],
+ );
+ check_expected_type_and_name(
+ r#"
+struct Foo { field: u32 }
+fn foo($0: Foo) {}
+"#,
+ // FIXME make this work, currently fails due to pattern recovery eating the `:`
+ expect![[r#"ty: ?, name: ?"#]],
+ );
+ }
}