7 files changed, 172 insertions, 51 deletions

diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 4dcea19a9..f33676655 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -11,17 +11,16 @@ use ra_syntax::{
     },
     AstNode, AstPtr, SyntaxNodePtr,
 };
+use test_utils::tested_by;
 
 use crate::{
     name::{AsName, SELF_PARAM},
+    path::GenericArgs,
+    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
     type_ref::{Mutability, TypeRef},
     DefWithBody, Either, HasSource, HirDatabase, HirFileId, MacroCallLoc, MacroFileKind, Name,
     Path, Resolver,
 };
-use crate::{
-    path::GenericArgs,
-    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
-};
 
 pub use self::scope::ExprScopes;
 
@@ -558,37 +557,40 @@ where
         let syntax_ptr = SyntaxNodePtr::new(expr.syntax());
         match expr.kind() {
             ast::ExprKind::IfExpr(e) => {
-                if let Some(pat) = e.condition().and_then(|c| c.pat()) {
-                    // if let -- desugar to match
-                    let pat = self.collect_pat(pat);
-                    let match_expr =
-                        self.collect_expr_opt(e.condition().expect("checked above").expr());
-                    let then_branch = self.collect_block_opt(e.then_branch());
-                    let else_branch = e
-                        .else_branch()
-                        .map(|b| match b {
-                            ast::ElseBranch::Block(it) => self.collect_block(it),
-                            ast::ElseBranch::IfExpr(elif) => self.collect_expr(elif.into()),
-                        })
-                        .unwrap_or_else(|| self.empty_block());
-                    let placeholder_pat = self.pats.alloc(Pat::Missing);
-                    let arms = vec![
-                        MatchArm { pats: vec![pat], expr: then_branch, guard: None },
-                        MatchArm { pats: vec![placeholder_pat], expr: else_branch, guard: None },
-                    ];
-                    self.alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr)
-                } else {
-                    let condition = self.collect_expr_opt(e.condition().and_then(|c| c.expr()));
-                    let then_branch = self.collect_block_opt(e.then_branch());
-                    let else_branch = e.else_branch().map(|b| match b {
-                        ast::ElseBranch::Block(it) => self.collect_block(it),
-                        ast::ElseBranch::IfExpr(elif) => {
-                            let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
-                            self.collect_expr(expr)
+                let then_branch = self.collect_block_opt(e.then_branch());
+
+                let else_branch = e.else_branch().map(|b| match b {
+                    ast::ElseBranch::Block(it) => self.collect_block(it),
+                    ast::ElseBranch::IfExpr(elif) => {
+                        let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
+                        self.collect_expr(expr)
+                    }
+                });
+
+                let condition = match e.condition() {
+                    None => self.exprs.alloc(Expr::Missing),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.pats.alloc(Pat::Missing);
+                            let arms = vec![
+                                MatchArm { pats: vec![pat], expr: then_branch, guard: None },
+                                MatchArm {
+                                    pats: vec![placeholder_pat],
+                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
+                                    guard: None,
+                                },
+                            ];
+                            return self
+                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
                         }
-                    });
-                    self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
-                }
+                    },
+                };
+
+                self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
             }
             ast::ExprKind::TryBlockExpr(e) => {
                 let body = self.collect_block_opt(e.try_body());
@@ -600,17 +602,30 @@ where
                 self.alloc_expr(Expr::Loop { body }, syntax_ptr)
             }
             ast::ExprKind::WhileExpr(e) => {
-                let condition = if let Some(condition) = e.condition() {
-                    if condition.pat().is_none() {
-                        self.collect_expr_opt(condition.expr())
-                    } else {
-                        // FIXME handle while let
-                        return self.alloc_expr(Expr::Missing, syntax_ptr);
-                    }
-                } else {
-                    self.exprs.alloc(Expr::Missing)
-                };
                 let body = self.collect_block_opt(e.loop_body());
+
+                let condition = match e.condition() {
+                    None => self.exprs.alloc(Expr::Missing),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            tested_by!(infer_while_let);
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.pats.alloc(Pat::Missing);
+                            let break_ = self.exprs.alloc(Expr::Break { expr: None });
+                            let arms = vec![
+                                MatchArm { pats: vec![pat], expr: body, guard: None },
+                                MatchArm { pats: vec![placeholder_pat], expr: break_, guard: None },
+                            ];
+                            let match_expr =
+                                self.exprs.alloc(Expr::Match { expr: match_expr, arms });
+                            return self.alloc_expr(Expr::Loop { body: match_expr }, syntax_ptr);
+                        }
+                    },
+                };
+
                 self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
             }
             ast::ExprKind::ForExpr(e) => {
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index 2d831f0d8..5b15eee90 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -10,4 +10,5 @@ test_utils::marks!(
     std_prelude
     match_ergonomics_ref
     trait_resolution_on_fn_type
+    infer_while_let
 );
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 36dea17a3..d5f7a4d25 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -145,6 +145,26 @@ mod collections {
 }
 
 #[test]
+fn infer_while_let() {
+    covers!(infer_while_let);
+    let (db, pos) = MockDatabase::with_position(
+        r#"
+//- /main.rs
+enum Option<T> { Some(T), None }
+
+fn test() {
+    let foo: Option<f32> = None;
+    while let Option::Some(x) = foo {
+        <|>x
+    }
+}
+
+"#,
+    );
+    assert_eq!("f32", type_at_pos(&db, pos));
+}
+
+#[test]
 fn infer_basics() {
     assert_snapshot_matches!(
         infer(r#"
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
index 7b9190314..0b3c96d26 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -414,13 +414,35 @@ fn main() {
 }"#,
         );
 
-        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
-    InlayHint {
-        range: [166; 170),
-        kind: TypeHint,
-        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",
+       ⋮    },
+       ⋮]
+        "###
         );
     }
 
diff --git a/crates/ra_parser/src/grammar/type_args.rs b/crates/ra_parser/src/grammar/type_args.rs
index f391b63db..3db08b280 100644
--- a/crates/ra_parser/src/grammar/type_args.rs
+++ b/crates/ra_parser/src/grammar/type_args.rs
@@ -35,6 +35,13 @@ fn type_arg(p: &mut Parser) {
             p.bump();
             m.complete(p, LIFETIME_ARG);
         }
+        // test associated_type_bounds
+        // fn print_all<T: Iterator<Item: Display>>(printables: T) {}
+        IDENT if p.nth(1) == T![:] => {
+            name_ref(p);
+            type_params::bounds(p);
+            m.complete(p, ASSOC_TYPE_ARG);
+        }
         IDENT if p.nth(1) == T![=] => {
             name_ref(p);
             p.bump();
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rs b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rs
new file mode 100644
index 000000000..eb21a657b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rs
@@ -0,0 +1 @@
+fn print_all<T: Iterator<Item: Display>>(printables: T) {}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.txt b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.txt
new file mode 100644
index 000000000..33e75510d
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.txt
@@ -0,0 +1,55 @@
+SOURCE_FILE@[0; 59)
+  FN_DEF@[0; 58)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 12)
+      IDENT@[3; 12) "print_all"
+    TYPE_PARAM_LIST@[12; 40)
+      L_ANGLE@[12; 13) "<"
+      TYPE_PARAM@[13; 39)
+        NAME@[13; 14)
+          IDENT@[13; 14) "T"
+        COLON@[14; 15) ":"
+        WHITESPACE@[15; 16) " "
+        TYPE_BOUND_LIST@[16; 39)
+          TYPE_BOUND@[16; 39)
+            PATH_TYPE@[16; 39)
+              PATH@[16; 39)
+                PATH_SEGMENT@[16; 39)
+                  NAME_REF@[16; 24)
+                    IDENT@[16; 24) "Iterator"
+                  TYPE_ARG_LIST@[24; 39)
+                    L_ANGLE@[24; 25) "<"
+                    ASSOC_TYPE_ARG@[25; 38)
+                      NAME_REF@[25; 29)
+                        IDENT@[25; 29) "Item"
+                      COLON@[29; 30) ":"
+                      WHITESPACE@[30; 31) " "
+                      TYPE_BOUND_LIST@[31; 38)
+                        TYPE_BOUND@[31; 38)
+                          PATH_TYPE@[31; 38)
+                            PATH@[31; 38)
+                              PATH_SEGMENT@[31; 38)
+                                NAME_REF@[31; 38)
+                                  IDENT@[31; 38) "Display"
+                    R_ANGLE@[38; 39) ">"
+      R_ANGLE@[39; 40) ">"
+    PARAM_LIST@[40; 55)
+      L_PAREN@[40; 41) "("
+      PARAM@[41; 54)
+        BIND_PAT@[41; 51)
+          NAME@[41; 51)
+            IDENT@[41; 51) "printables"
+        COLON@[51; 52) ":"
+        WHITESPACE@[52; 53) " "
+        PATH_TYPE@[53; 54)
+          PATH@[53; 54)
+            PATH_SEGMENT@[53; 54)
+              NAME_REF@[53; 54)
+                IDENT@[53; 54) "T"
+      R_PAREN@[54; 55) ")"
+    WHITESPACE@[55; 56) " "
+    BLOCK@[56; 58)
+      L_CURLY@[56; 57) "{"
+      R_CURLY@[57; 58) "}"
+  WHITESPACE@[58; 59) "\n"