3 files changed, 127 insertions, 72 deletions

diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index 536ba36df..d43ff2eec 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -1,19 +1,36 @@
 use hir::{AdtDef, Ty, TypeCtor};
 
-use crate::completion::{CompletionContext, Completions};
+use crate::completion::completion_item::CompletionKind;
+use crate::{
+    completion::{completion_context::CompletionContext, completion_item::Completions},
+    CompletionItem,
+};
 use rustc_hash::FxHashSet;
 
-/// Complete dot accesses, i.e. fields or methods (currently only fields).
+/// Complete dot accesses, i.e. fields or methods (and .await syntax).
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
-    let receiver_ty =
-        match ctx.dot_receiver.as_ref().and_then(|it| ctx.analyzer.type_of(ctx.db, it)) {
-            Some(it) => it,
-            None => return,
-        };
+    let dot_receiver = match &ctx.dot_receiver {
+        Some(expr) => expr,
+        _ => return,
+    };
+
+    let receiver_ty = match ctx.analyzer.type_of(ctx.db, &dot_receiver) {
+        Some(ty) => ty,
+        _ => return,
+    };
+
     if !ctx.is_call {
         complete_fields(acc, ctx, receiver_ty.clone());
     }
-    complete_methods(acc, ctx, receiver_ty);
+    complete_methods(acc, ctx, receiver_ty.clone());
+
+    // Suggest .await syntax for types that implement Future trait
+    if ctx.analyzer.impls_future(ctx.db, receiver_ty) {
+        CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+            .detail("expr.await")
+            .insert_text("await")
+            .add_to(acc);
+    }
 }
 
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) {
@@ -406,4 +423,36 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn test_completion_await_impls_future() {
+        assert_debug_snapshot_matches!(
+        do_completion(
+            r###"
+            //- /main.rs
+            use std::future::*;
+            struct A {}
+            impl Future for A {}
+            fn foo(a: A) {
+                a.<|>
+            }
+
+            //- /std/lib.rs
+            pub mod future {
+                pub trait Future {}
+            }
+            "###, CompletionKind::Keyword),
+        @r###"
+       ⋮[
+       ⋮    CompletionItem {
+       ⋮        label: "await",
+       ⋮        source_range: [74; 74),
+       ⋮        delete: [74; 74),
+       ⋮        insert: "await",
+       ⋮        detail: "expr.await",
+       ⋮    },
+       ⋮]
+        "###
+        )
+    }
 }
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index 028dc3d4f..98b840b26 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -48,7 +48,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
         })
     })
     .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-        let source_root = db.file_source_root(d.file().original_file(db));
+        let source_root = db.file_source_root(d.source().file_id.original_file(db));
         let create_file = FileSystemEdit::CreateFile { source_root, path: d.candidate.clone() };
         let fix = SourceChange::file_system_edit("create module", create_file);
         res.borrow_mut().push(Diagnostic {
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
index a524e014f..0b3c96d26 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -9,14 +9,9 @@ use ra_syntax::{
     SmolStr, SyntaxKind, SyntaxNode, TextRange,
 };
 
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum InlayKind {
-    LetBindingType,
-    ClosureParameterType,
-    ForExpressionBindingType,
-    IfExpressionType,
-    WhileLetExpressionType,
-    MatchArmType,
+    TypeHint,
 }
 
 #[derive(Debug)]
@@ -46,7 +41,7 @@ fn get_inlay_hints(
             }
             let pat = let_statement.pat()?;
             let analyzer = SourceAnalyzer::new(db, file_id, let_statement.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::LetBindingType, false))
+            Some(get_pat_type_hints(db, &analyzer, pat, false))
         })
         .visit(|closure_parameter: LambdaExpr| {
             let analyzer = SourceAnalyzer::new(db, file_id, closure_parameter.syntax(), None);
@@ -55,15 +50,7 @@ fn get_inlay_hints(
                     .params()
                     .filter(|closure_param| closure_param.ascribed_type().is_none())
                     .filter_map(|closure_param| closure_param.pat())
-                    .map(|root_pat| {
-                        get_pat_hints(
-                            db,
-                            &analyzer,
-                            root_pat,
-                            InlayKind::ClosureParameterType,
-                            false,
-                        )
-                    })
+                    .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, false))
                     .flatten()
                     .collect()
             })
@@ -71,17 +58,17 @@ fn get_inlay_hints(
         .visit(|for_expression: ForExpr| {
             let pat = for_expression.pat()?;
             let analyzer = SourceAnalyzer::new(db, file_id, for_expression.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::ForExpressionBindingType, false))
+            Some(get_pat_type_hints(db, &analyzer, pat, false))
         })
         .visit(|if_expr: IfExpr| {
             let pat = if_expr.condition()?.pat()?;
             let analyzer = SourceAnalyzer::new(db, file_id, if_expr.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::IfExpressionType, true))
+            Some(get_pat_type_hints(db, &analyzer, pat, true))
         })
         .visit(|while_expr: WhileExpr| {
             let pat = while_expr.condition()?.pat()?;
             let analyzer = SourceAnalyzer::new(db, file_id, while_expr.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::WhileLetExpressionType, true))
+            Some(get_pat_type_hints(db, &analyzer, pat, true))
         })
         .visit(|match_arm_list: MatchArmList| {
             let analyzer = SourceAnalyzer::new(db, file_id, match_arm_list.syntax(), None);
@@ -90,9 +77,7 @@ fn get_inlay_hints(
                     .arms()
                     .map(|match_arm| match_arm.pats())
                     .flatten()
-                    .map(|root_pat| {
-                        get_pat_hints(db, &analyzer, root_pat, InlayKind::MatchArmType, true)
-                    })
+                    .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, true))
                     .flatten()
                     .collect(),
             )
@@ -100,11 +85,10 @@ fn get_inlay_hints(
         .accept(&node)?
 }
 
-fn get_pat_hints(
+fn get_pat_type_hints(
     db: &RootDatabase,
     analyzer: &SourceAnalyzer,
     root_pat: Pat,
-    kind: InlayKind,
     skip_root_pat_hint: bool,
 ) -> Vec<InlayHint> {
     let original_pat = &root_pat.clone();
@@ -118,7 +102,7 @@ fn get_pat_hints(
         })
         .map(|(range, pat_type)| InlayHint {
             range,
-            kind: kind.clone(),
+            kind: InlayKind::TypeHint,
             label: pat_type.display(db).to_string().into(),
         })
         .collect()
@@ -232,52 +216,52 @@ fn main() {
         assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
     InlayHint {
         range: [193; 197),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [236; 244),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [275; 279),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "&str",
     },
     InlayHint {
         range: [539; 543),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "(i32, char)",
     },
     InlayHint {
         range: [566; 567),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [570; 571),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [573; 574),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [584; 585),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [577; 578),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "f64",
     },
     InlayHint {
         range: [580; 581),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "f64",
     },
 ]"#
@@ -299,12 +283,12 @@ fn main() {
         assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
     InlayHint {
         range: [21; 30),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [57; 66),
-        kind: ClosureParameterType,
+        kind: TypeHint,
         label: "i32",
     },
 ]"#
@@ -326,12 +310,12 @@ fn main() {
         assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
     InlayHint {
         range: [21; 30),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "i32",
     },
     InlayHint {
         range: [44; 53),
-        kind: ForExpressionBindingType,
+        kind: TypeHint,
         label: "i32",
     },
 ]"#
@@ -364,7 +348,7 @@ fn main() {
     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 {}
 }"#,
         );
@@ -372,27 +356,27 @@ fn main() {
         assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
     InlayHint {
         range: [166; 170),
-        kind: LetBindingType,
+        kind: TypeHint,
         label: "CustomOption<Test>",
     },
     InlayHint {
         range: [334; 338),
-        kind: IfExpressionType,
+        kind: TypeHint,
         label: "&Test",
     },
     InlayHint {
         range: [389; 390),
-        kind: IfExpressionType,
+        kind: TypeHint,
         label: "&CustomOption<u32>",
     },
     InlayHint {
         range: [392; 393),
-        kind: IfExpressionType,
+        kind: TypeHint,
         label: "&u8",
     },
     InlayHint {
         range: [531; 532),
-        kind: IfExpressionType,
+        kind: TypeHint,
         label: "&u32",
     },
 ]"#
@@ -425,18 +409,40 @@ fn main() {
     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 {}
 }"#,
         );
 
-        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
-    InlayHint {
-        range: [166; 170),
-        kind: LetBindingType,
-        label: "CustomOption<Test>",
-    },
-]"#
+        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r###"
+       ⋮[
+       ⋮    InlayHint {
+       ⋮        range: [166; 170),
+       ⋮        kind: TypeHint,
+       ⋮        label: "CustomOption<Test>",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [343; 347),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&Test",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [401; 402),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&CustomOption<u32>",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [404; 405),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&u8",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [549; 550),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&u32",
+       ⋮    },
+       ⋮]
+        "###
         );
     }
 
@@ -445,7 +451,7 @@ fn main() {
         let (analysis, file_id) = single_file(
             r#"
 #[derive(PartialEq)]
-enum CustomOption<T> { 
+enum CustomOption<T> {
     None,
     Some(T),
 }
@@ -473,23 +479,23 @@ fn main() {
 
         assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
     InlayHint {
-        range: [312; 316),
-        kind: MatchArmType,
+        range: [311; 315),
+        kind: TypeHint,
         label: "Test",
     },
     InlayHint {
-        range: [359; 360),
-        kind: MatchArmType,
+        range: [358; 359),
+        kind: TypeHint,
         label: "CustomOption<u32>",
     },
     InlayHint {
-        range: [362; 363),
-        kind: MatchArmType,
+        range: [361; 362),
+        kind: TypeHint,
         label: "u8",
     },
     InlayHint {
-        range: [485; 486),
-        kind: MatchArmType,
+        range: [484; 485),
+        kind: TypeHint,
         label: "u32",
     },
 ]"#