1 files changed, 145 insertions, 118 deletions

diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index a484dfdeb..35e3f782d 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,12 +1,11 @@
 //! FIXME: write short doc here
 
-use hir::{HirDisplay, SourceAnalyzer, SourceBinder};
-use once_cell::unsync::Lazy;
+use hir::{Adt, HirDisplay, Semantics, Type};
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, SmolStr, SourceFile, SyntaxNode, TextRange,
+    match_ast, SmolStr, SyntaxNode, TextRange,
 };
 
 use crate::{FileId, FunctionSignature};
@@ -27,42 +26,38 @@ pub struct InlayHint {
 pub(crate) fn inlay_hints(
     db: &RootDatabase,
     file_id: FileId,
-    file: &SourceFile,
     max_inlay_hint_length: Option<usize>,
 ) -> Vec<InlayHint> {
-    let mut sb = SourceBinder::new(db);
+    let sema = Semantics::new(db);
+    let file = sema.parse(file_id);
     let mut res = Vec::new();
     for node in file.syntax().descendants() {
-        get_inlay_hints(&mut res, &mut sb, file_id, &node, max_inlay_hint_length);
+        get_inlay_hints(&mut res, &sema, &node, max_inlay_hint_length);
     }
     res
 }
 
 fn get_inlay_hints(
     acc: &mut Vec<InlayHint>,
-    sb: &mut SourceBinder<RootDatabase>,
-    file_id: FileId,
+    sema: &Semantics<RootDatabase>,
     node: &SyntaxNode,
     max_inlay_hint_length: Option<usize>,
 ) -> Option<()> {
     let _p = profile("get_inlay_hints");
-    let db = sb.db;
-    let analyzer = Lazy::new(move || sb.analyze(hir::InFile::new(file_id.into(), node), None));
+    let db = sema.db;
     match_ast! {
         match node {
             ast::CallExpr(it) => {
-                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+                get_param_name_hints(acc, sema, ast::Expr::from(it));
             },
             ast::MethodCallExpr(it) => {
-                get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
+                get_param_name_hints(acc, sema, ast::Expr::from(it));
             },
             ast::BindPat(it) => {
-                if should_not_display_type_hint(&it) {
-                    return None;
-                }
-                let pat = ast::Pat::from(it);
-                let ty = analyzer.type_of_pat(db, &pat)?;
-                if ty.is_unknown() {
+                let pat = ast::Pat::from(it.clone());
+                let ty = sema.type_of_pat(&pat)?;
+
+                if should_not_display_type_hint(db, &it, &ty) {
                     return None;
                 }
 
@@ -80,7 +75,24 @@ fn get_inlay_hints(
     Some(())
 }
 
-fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
+fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
+    if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
+        let pat_text = bind_pat.syntax().to_string();
+        enum_data
+            .variants(db)
+            .into_iter()
+            .map(|variant| variant.name(db).to_string())
+            .any(|enum_name| enum_name == pat_text)
+    } else {
+        false
+    }
+}
+
+fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
+    if pat_ty.is_unknown() {
+        return true;
+    }
+
     for node in bind_pat.syntax().ancestors() {
         match_ast! {
             match node {
@@ -90,6 +102,17 @@ fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
                 ast::Param(it) => {
                     return it.ascribed_type().is_some()
                 },
+                ast::MatchArm(_it) => {
+                    return pat_is_enum_variant(db, bind_pat, pat_ty);
+                },
+                ast::IfExpr(it) => {
+                    return it.condition().and_then(|condition| condition.pat()).is_some()
+                        && pat_is_enum_variant(db, bind_pat, pat_ty);
+                },
+                ast::WhileExpr(it) => {
+                    return it.condition().and_then(|condition| condition.pat()).is_some()
+                        && pat_is_enum_variant(db, bind_pat, pat_ty);
+                },
                 _ => (),
             }
         }
@@ -99,8 +122,7 @@ fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
 
 fn get_param_name_hints(
     acc: &mut Vec<InlayHint>,
-    db: &RootDatabase,
-    analyzer: &SourceAnalyzer,
+    sema: &Semantics<RootDatabase>,
     expr: ast::Expr,
 ) -> Option<()> {
     let args = match &expr {
@@ -112,20 +134,19 @@ fn get_param_name_hints(
     // we need args len to determine whether to skip or not the &self parameter
     .collect::<Vec<_>>();
 
-    let fn_signature = get_fn_signature(db, analyzer, &expr)?;
+    let fn_signature = get_fn_signature(sema, &expr)?;
     let n_params_to_skip =
         if fn_signature.has_self_param && fn_signature.parameter_names.len() > args.len() {
             1
         } else {
             0
         };
-    let parameters = fn_signature.parameter_names.iter().skip(n_params_to_skip);
-
-    let hints = parameters
+    let hints = fn_signature
+        .parameter_names
+        .iter()
+        .skip(n_params_to_skip)
         .zip(args)
-        .filter(|(param, arg)| {
-            should_show_param_hint(&fn_signature, param, &arg.syntax().to_string())
-        })
+        .filter(|(param, arg)| should_show_param_hint(&fn_signature, param, &arg))
         .map(|(param_name, arg)| InlayHint {
             range: arg.syntax().text_range(),
             kind: InlayKind::ParameterHint,
@@ -139,8 +160,9 @@ fn get_param_name_hints(
 fn should_show_param_hint(
     fn_signature: &FunctionSignature,
     param_name: &str,
-    argument_string: &str,
+    argument: &ast::Expr,
 ) -> bool {
+    let argument_string = argument.syntax().to_string();
     if param_name.is_empty() || argument_string.ends_with(param_name) {
         return false;
     }
@@ -158,28 +180,26 @@ fn should_show_param_hint(
     true
 }
 
-fn get_fn_signature(
-    db: &RootDatabase,
-    analyzer: &SourceAnalyzer,
-    expr: &ast::Expr,
-) -> Option<FunctionSignature> {
+fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<FunctionSignature> {
     match expr {
         ast::Expr::CallExpr(expr) => {
             // FIXME: Type::as_callable is broken for closures
-            let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+            let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
             match callable_def {
                 hir::CallableDef::FunctionId(it) => {
-                    Some(FunctionSignature::from_hir(db, it.into()))
+                    Some(FunctionSignature::from_hir(sema.db, it.into()))
+                }
+                hir::CallableDef::StructId(it) => {
+                    FunctionSignature::from_struct(sema.db, it.into())
                 }
-                hir::CallableDef::StructId(it) => FunctionSignature::from_struct(db, it.into()),
                 hir::CallableDef::EnumVariantId(it) => {
-                    FunctionSignature::from_enum_variant(db, it.into())
+                    FunctionSignature::from_enum_variant(sema.db, it.into())
                 }
             }
         }
         ast::Expr::MethodCallExpr(expr) => {
-            let fn_def = analyzer.resolve_method_call(&expr)?;
-            Some(FunctionSignature::from_hir(db, fn_def))
+            let fn_def = sema.resolve_method_call(&expr)?;
+            Some(FunctionSignature::from_hir(sema.db, fn_def))
         }
         _ => None,
     }
@@ -440,75 +460,77 @@ struct Test {
     b: u8,
 }
 
+use CustomOption::*;
+
 fn main() {
-    let test = CustomOption::Some(Test { a: CustomOption::Some(3), b: 1 });
-    if let CustomOption::None = &test {};
+    let test = Some(Test { a: Some(3), b: 1 });
+    if let None = &test {};
     if let test = &test {};
-    if let CustomOption::Some(test) = &test {};
-    if let CustomOption::Some(Test { a, b }) = &test {};
-    if let CustomOption::Some(Test { a: x, b: y }) = &test {};
-    if let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
-    if let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
-    if let CustomOption::Some(Test { b: y, .. }) = &test {};
-
-    if test == CustomOption::None {}
+    if let Some(test) = &test {};
+    if let Some(Test { a, b }) = &test {};
+    if let Some(Test { a: x, b: y }) = &test {};
+    if let Some(Test { a: Some(x), b: y }) = &test {};
+    if let Some(Test { a: None, b: y }) = &test {};
+    if let Some(Test { b: y, .. }) = &test {};
+
+    if test == None {}
 }"#,
         );
 
         assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
         [
             InlayHint {
-                range: [166; 170),
+                range: [188; 192),
                 kind: TypeHint,
                 label: "CustomOption<Test>",
             },
             InlayHint {
-                range: [287; 291),
+                range: [267; 271),
                 kind: TypeHint,
                 label: "&CustomOption<Test>",
             },
             InlayHint {
-                range: [334; 338),
+                range: [300; 304),
                 kind: TypeHint,
                 label: "&Test",
             },
             InlayHint {
-                range: [389; 390),
+                range: [341; 342),
                 kind: TypeHint,
                 label: "&CustomOption<u32>",
             },
             InlayHint {
-                range: [392; 393),
+                range: [344; 345),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [449; 450),
+                range: [387; 388),
                 kind: TypeHint,
                 label: "&CustomOption<u32>",
             },
             InlayHint {
-                range: [455; 456),
+                range: [393; 394),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [531; 532),
+                range: [441; 442),
                 kind: TypeHint,
                 label: "&u32",
             },
             InlayHint {
-                range: [538; 539),
+                range: [448; 449),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [618; 619),
+                range: [500; 501),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [675; 676),
+                range: [543; 544),
                 kind: TypeHint,
                 label: "&u8",
             },
@@ -533,75 +555,77 @@ struct Test {
     b: u8,
 }
 
+use CustomOption::*;
+
 fn main() {
-    let test = CustomOption::Some(Test { a: CustomOption::Some(3), b: 1 });
-    while let CustomOption::None = &test {};
+    let test = Some(Test { a: Some(3), b: 1 });
+    while let None = &test {};
     while let test = &test {};
-    while let CustomOption::Some(test) = &test {};
-    while let CustomOption::Some(Test { a, b }) = &test {};
-    while let CustomOption::Some(Test { a: x, b: y }) = &test {};
-    while let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
-    while let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
-    while let CustomOption::Some(Test { b: y, .. }) = &test {};
-
-    while test == CustomOption::None {}
+    while let Some(test) = &test {};
+    while let Some(Test { a, b }) = &test {};
+    while let Some(Test { a: x, b: y }) = &test {};
+    while let Some(Test { a: Some(x), b: y }) = &test {};
+    while let Some(Test { a: None, b: y }) = &test {};
+    while let Some(Test { b: y, .. }) = &test {};
+
+    while test == None {}
 }"#,
         );
 
         assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
         [
             InlayHint {
-                range: [166; 170),
+                range: [188; 192),
                 kind: TypeHint,
                 label: "CustomOption<Test>",
             },
             InlayHint {
-                range: [293; 297),
+                range: [273; 277),
                 kind: TypeHint,
                 label: "&CustomOption<Test>",
             },
             InlayHint {
-                range: [343; 347),
+                range: [309; 313),
                 kind: TypeHint,
                 label: "&Test",
             },
             InlayHint {
-                range: [401; 402),
+                range: [353; 354),
                 kind: TypeHint,
                 label: "&CustomOption<u32>",
             },
             InlayHint {
-                range: [404; 405),
+                range: [356; 357),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [464; 465),
+                range: [402; 403),
                 kind: TypeHint,
                 label: "&CustomOption<u32>",
             },
             InlayHint {
-                range: [470; 471),
+                range: [408; 409),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [549; 550),
+                range: [459; 460),
                 kind: TypeHint,
                 label: "&u32",
             },
             InlayHint {
-                range: [556; 557),
+                range: [466; 467),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [639; 640),
+                range: [521; 522),
                 kind: TypeHint,
                 label: "&u8",
             },
             InlayHint {
-                range: [699; 700),
+                range: [567; 568),
                 kind: TypeHint,
                 label: "&u8",
             },
@@ -626,16 +650,18 @@ struct Test {
     b: u8,
 }
 
+use CustomOption::*;
+
 fn main() {
-    match CustomOption::Some(Test { a: CustomOption::Some(3), b: 1 }) {
-        CustomOption::None => (),
+    match Some(Test { a: Some(3), b: 1 }) {
+        None => (),
         test => (),
-        CustomOption::Some(test) => (),
-        CustomOption::Some(Test { a, b }) => (),
-        CustomOption::Some(Test { a: x, b: y }) => (),
-        CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) => (),
-        CustomOption::Some(Test { a: CustomOption::None, b: y }) => (),
-        CustomOption::Some(Test { b: y, .. }) => (),
+        Some(test) => (),
+        Some(Test { a, b }) => (),
+        Some(Test { a: x, b: y }) => (),
+        Some(Test { a: Some(x), b: y }) => (),
+        Some(Test { a: None, b: y }) => (),
+        Some(Test { b: y, .. }) => (),
         _ => {}
     }
 }"#,
@@ -644,52 +670,52 @@ fn main() {
         assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
         [
             InlayHint {
-                range: [272; 276),
+                range: [252; 256),
                 kind: TypeHint,
                 label: "CustomOption<Test>",
             },
             InlayHint {
-                range: [311; 315),
+                range: [277; 281),
                 kind: TypeHint,
                 label: "Test",
             },
             InlayHint {
-                range: [358; 359),
+                range: [310; 311),
                 kind: TypeHint,
                 label: "CustomOption<u32>",
             },
             InlayHint {
-                range: [361; 362),
+                range: [313; 314),
                 kind: TypeHint,
                 label: "u8",
             },
             InlayHint {
-                range: [410; 411),
+                range: [348; 349),
                 kind: TypeHint,
                 label: "CustomOption<u32>",
             },
             InlayHint {
-                range: [416; 417),
+                range: [354; 355),
                 kind: TypeHint,
                 label: "u8",
             },
             InlayHint {
-                range: [484; 485),
+                range: [394; 395),
                 kind: TypeHint,
                 label: "u32",
             },
             InlayHint {
-                range: [491; 492),
+                range: [401; 402),
                 kind: TypeHint,
                 label: "u8",
             },
             InlayHint {
-                range: [563; 564),
+                range: [445; 446),
                 kind: TypeHint,
                 label: "u8",
             },
             InlayHint {
-                range: [612; 613),
+                range: [480; 481),
                 kind: TypeHint,
                 label: "u8",
             },
@@ -743,6 +769,7 @@ enum CustomOption<T> {
     None,
     Some(T),
 }
+use CustomOption::*;
 
 struct FileId {}
 struct SmolStr {}
@@ -791,11 +818,11 @@ fn main() {
     Test::from_syntax(
         FileId {},
         "impl".into(),
-        CustomOption::None,
+        None,
         TextRange {},
         SyntaxKind {},
-        CustomOption::None,
-        CustomOption::None,
+        None,
+        None,
     );
 }"#,
         );
@@ -803,77 +830,77 @@ fn main() {
         assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
         [
             InlayHint {
-                range: [777; 788),
+                range: [798; 809),
                 kind: TypeHint,
                 label: "i32",
             },
             InlayHint {
-                range: [821; 822),
+                range: [842; 843),
                 kind: ParameterHint,
                 label: "foo",
             },
             InlayHint {
-                range: [824; 825),
+                range: [845; 846),
                 kind: ParameterHint,
                 label: "bar",
             },
             InlayHint {
-                range: [827; 834),
+                range: [848; 855),
                 kind: ParameterHint,
                 label: "msg",
             },
             InlayHint {
-                range: [839; 850),
+                range: [860; 871),
                 kind: ParameterHint,
                 label: "last",
             },
             InlayHint {
-                range: [893; 896),
+                range: [914; 917),
                 kind: ParameterHint,
                 label: "param",
             },
             InlayHint {
-                range: [916; 918),
+                range: [937; 939),
                 kind: ParameterHint,
                 label: "&self",
             },
             InlayHint {
-                range: [920; 924),
+                range: [941; 945),
                 kind: ParameterHint,
                 label: "param",
             },
             InlayHint {
-                range: [959; 968),
+                range: [980; 989),
                 kind: ParameterHint,
                 label: "file_id",
             },
             InlayHint {
-                range: [978; 991),
+                range: [999; 1012),
                 kind: ParameterHint,
                 label: "name",
             },
             InlayHint {
-                range: [1001; 1019),
+                range: [1022; 1026),
                 kind: ParameterHint,
                 label: "focus_range",
             },
             InlayHint {
-                range: [1029; 1041),
+                range: [1036; 1048),
                 kind: ParameterHint,
                 label: "full_range",
             },
             InlayHint {
-                range: [1051; 1064),
+                range: [1058; 1071),
                 kind: ParameterHint,
                 label: "kind",
             },
             InlayHint {
-                range: [1074; 1092),
+                range: [1081; 1085),
                 kind: ParameterHint,
                 label: "docs",
             },
             InlayHint {
-                range: [1102; 1120),
+                range: [1095; 1099),
                 kind: ParameterHint,
                 label: "description",
             },