8 files changed, 278 insertions, 248 deletions

diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 3e19a7702..3a98ffbaa 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -862,30 +862,6 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
-    fn inner_items_from_parent_module() {
-        // FIXME: ItemTree currently associates all inner items with `main`. Luckily, this sort of
-        // code is very rare, so this isn't terrible.
-        // To fix it, we should probably build dedicated `ItemTree`s for inner items, and not store
-        // them in the file's main ItemTree. This would also allow us to stop parsing function
-        // bodies when we only want to compute the crate's main DefMap.
-        check_found_path(
-            r#"
-            fn main() {
-                struct Struct {}
-                mod module {
-                    $0
-                }
-            }
-        "#,
-            "super::Struct",
-            "super::Struct",
-            "super::Struct",
-            "super::Struct",
-        );
-    }
-
-    #[test]
     fn outer_items_with_inner_items_present() {
         check_found_path(
             r#"
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 22ddeeae3..1919639a3 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -88,6 +88,8 @@ pub(crate) fn rename_with_semantics(
     let def = find_definition(sema, syntax, position)?;
     match def {
         Definition::ModuleDef(ModuleDef::Module(module)) => rename_mod(&sema, module, new_name),
+        Definition::SelfType(_) => bail!("Cannot rename `Self`"),
+        Definition::ModuleDef(ModuleDef::BuiltinType(_)) => bail!("Cannot rename builtin type"),
         def => rename_reference(sema, def, new_name),
     }
 }
@@ -122,7 +124,7 @@ fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
                 Ok(IdentifierKind::Lifetime)
             }
             (SyntaxKind::LIFETIME_IDENT, _) => {
-                bail!("Invalid name `{0}`: Cannot rename lifetime to {0}", new_name)
+                bail!("Invalid name `{}`: not a lifetime identifier", new_name)
             }
             (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
             (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
@@ -162,119 +164,6 @@ fn find_definition(
     .ok_or_else(|| format_err!("No references found at position"))
 }
 
-fn source_edit_from_references(
-    _sema: &Semantics<RootDatabase>,
-    file_id: FileId,
-    references: &[FileReference],
-    def: Definition,
-    new_name: &str,
-) -> (FileId, TextEdit) {
-    let mut edit = TextEdit::builder();
-    for reference in references {
-        let (range, replacement) = match &reference.name {
-            // if the ranges differ then the node is inside a macro call, we can't really attempt
-            // to make special rewrites like shorthand syntax and such, so just rename the node in
-            // the macro input
-            ast::NameLike::NameRef(name_ref)
-                if name_ref.syntax().text_range() == reference.range =>
-            {
-                source_edit_from_name_ref(name_ref, new_name, def)
-            }
-            ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
-                source_edit_from_name(name, new_name)
-            }
-            _ => None,
-        }
-        .unwrap_or_else(|| (reference.range, new_name.to_string()));
-        edit.replace(range, replacement);
-    }
-    (file_id, edit.finish())
-}
-
-fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
-    if let Some(_) = ast::RecordPatField::for_field_name(name) {
-        if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
-            return Some((
-                TextRange::empty(ident_pat.syntax().text_range().start()),
-                format!("{}: ", new_name),
-            ));
-        }
-    }
-    None
-}
-
-fn source_edit_from_name_ref(
-    name_ref: &ast::NameRef,
-    new_name: &str,
-    def: Definition,
-) -> Option<(TextRange, String)> {
-    if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
-        let rcf_name_ref = record_field.name_ref();
-        let rcf_expr = record_field.expr();
-        match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
-            // field: init-expr, check if we can use a field init shorthand
-            (Some(field_name), Some(init)) => {
-                if field_name == *name_ref {
-                    if init.text() == new_name {
-                        mark::hit!(test_rename_field_put_init_shorthand);
-                        // same names, we can use a shorthand here instead.
-                        // we do not want to erase attributes hence this range start
-                        let s = field_name.syntax().text_range().start();
-                        let e = record_field.syntax().text_range().end();
-                        return Some((TextRange::new(s, e), new_name.to_owned()));
-                    }
-                } else if init == *name_ref {
-                    if field_name.text() == new_name {
-                        mark::hit!(test_rename_local_put_init_shorthand);
-                        // same names, we can use a shorthand here instead.
-                        // we do not want to erase attributes hence this range start
-                        let s = field_name.syntax().text_range().start();
-                        let e = record_field.syntax().text_range().end();
-                        return Some((TextRange::new(s, e), new_name.to_owned()));
-                    }
-                }
-                None
-            }
-            // init shorthand
-            // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
-            // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
-            (None, Some(_)) if matches!(def, Definition::Field(_)) => {
-                mark::hit!(test_rename_field_in_field_shorthand);
-                let s = name_ref.syntax().text_range().start();
-                Some((TextRange::empty(s), format!("{}: ", new_name)))
-            }
-            (None, Some(_)) if matches!(def, Definition::Local(_)) => {
-                mark::hit!(test_rename_local_in_field_shorthand);
-                let s = name_ref.syntax().text_range().end();
-                Some((TextRange::empty(s), format!(": {}", new_name)))
-            }
-            _ => None,
-        }
-    } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
-        let rcf_name_ref = record_field.name_ref();
-        let rcf_pat = record_field.pat();
-        match (rcf_name_ref, rcf_pat) {
-            // field: rename
-            (Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
-                // field name is being renamed
-                if pat.name().map_or(false, |it| it.text() == new_name) {
-                    mark::hit!(test_rename_field_put_init_shorthand_pat);
-                    // same names, we can use a shorthand here instead/
-                    // we do not want to erase attributes hence this range start
-                    let s = field_name.syntax().text_range().start();
-                    let e = record_field.syntax().text_range().end();
-                    Some((TextRange::new(s, e), pat.to_string()))
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
 fn rename_mod(
     sema: &Semantics<RootDatabase>,
     module: Module,
@@ -308,18 +197,75 @@ fn rename_mod(
                 TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
             ),
             _ => unreachable!(),
-        };
+        }
     }
     let def = Definition::ModuleDef(ModuleDef::Module(module));
     let usages = def.usages(sema).all();
     let ref_edits = usages.iter().map(|(&file_id, references)| {
-        source_edit_from_references(sema, file_id, references, def, new_name)
+        (file_id, source_edit_from_references(references, def, new_name))
     });
     source_change.extend(ref_edits);
 
     Ok(source_change)
 }
 
+fn rename_reference(
+    sema: &Semantics<RootDatabase>,
+    def: Definition,
+    new_name: &str,
+) -> RenameResult<SourceChange> {
+    let ident_kind = check_identifier(new_name)?;
+
+    let def_is_lbl_or_lt = matches!(
+        def,
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+    );
+    match (ident_kind, def) {
+        (IdentifierKind::ToSelf, _)
+        | (IdentifierKind::Underscore, _)
+        | (IdentifierKind::Ident, _)
+            if def_is_lbl_or_lt =>
+        {
+            mark::hit!(rename_not_a_lifetime_ident_ref);
+            bail!("Invalid name `{}`: not a lifetime identifier", new_name)
+        }
+        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => mark::hit!(rename_lifetime),
+        (IdentifierKind::Lifetime, _) => {
+            mark::hit!(rename_not_an_ident_ref);
+            bail!("Invalid name `{}`: not an identifier", new_name)
+        }
+        (IdentifierKind::ToSelf, Definition::Local(local)) if local.is_self(sema.db) => {
+            // no-op
+            mark::hit!(rename_self_to_self);
+            return Ok(SourceChange::default());
+        }
+        (ident_kind, Definition::Local(local)) if local.is_self(sema.db) => {
+            mark::hit!(rename_self_to_param);
+            return rename_self_to_param(sema, local, new_name, ident_kind);
+        }
+        (IdentifierKind::ToSelf, Definition::Local(local)) => {
+            mark::hit!(rename_to_self);
+            return rename_to_self(sema, local);
+        }
+        (IdentifierKind::ToSelf, _) => bail!("Invalid name `{}`: not an identifier", new_name),
+        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
+    }
+
+    let usages = def.usages(sema).all();
+    if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
+        mark::hit!(rename_underscore_multiple);
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+    }
+    let mut source_change = SourceChange::default();
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
+        (file_id, source_edit_from_references(&references, def, new_name))
+    }));
+
+    let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
+    source_change.insert_source_edit(file_id, edit);
+    Ok(source_change)
+}
+
 fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
     if never!(local.is_self(sema.db)) {
         bail!("rename_to_self invoked on self");
@@ -384,7 +330,7 @@ fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameRe
     let usages = def.usages(sema).all();
     let mut source_change = SourceChange::default();
     source_change.extend(usages.iter().map(|(&file_id, references)| {
-        source_edit_from_references(sema, file_id, references, def, "self")
+        (file_id, source_edit_from_references(references, def, "self"))
     }));
     source_change.insert_source_edit(
         file_id.original_file(sema.db),
@@ -394,29 +340,6 @@ fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameRe
     Ok(source_change)
 }
 
-fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Option<TextEdit> {
-    fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
-        if let Some(ast::Type::PathType(p)) = impl_def.self_ty() {
-            return Some(p.path()?.segment()?.name_ref()?.text().to_string());
-        }
-        None
-    }
-
-    let impl_def = self_param.syntax().ancestors().find_map(|it| ast::Impl::cast(it))?;
-    let type_name = target_type_name(&impl_def)?;
-
-    let mut replacement_text = String::from(new_name);
-    replacement_text.push_str(": ");
-    match (self_param.amp_token(), self_param.mut_token()) {
-        (None, None) => (),
-        (Some(_), None) => replacement_text.push('&'),
-        (_, Some(_)) => replacement_text.push_str("&mut "),
-    };
-    replacement_text.push_str(type_name.as_str());
-
-    Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
-}
-
 fn rename_self_to_param(
     sema: &Semantics<RootDatabase>,
     local: hir::Local,
@@ -441,66 +364,143 @@ fn rename_self_to_param(
     let mut source_change = SourceChange::default();
     source_change.insert_source_edit(file_id.original_file(sema.db), edit);
     source_change.extend(usages.iter().map(|(&file_id, references)| {
-        source_edit_from_references(sema, file_id, &references, def, new_name)
+        (file_id, source_edit_from_references(&references, def, new_name))
     }));
     Ok(source_change)
 }
 
-fn rename_reference(
-    sema: &Semantics<RootDatabase>,
+fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Option<TextEdit> {
+    fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
+        if let Some(ast::Type::PathType(p)) = impl_def.self_ty() {
+            return Some(p.path()?.segment()?.name_ref()?.text().to_string());
+        }
+        None
+    }
+
+    let impl_def = self_param.syntax().ancestors().find_map(|it| ast::Impl::cast(it))?;
+    let type_name = target_type_name(&impl_def)?;
+
+    let mut replacement_text = String::from(new_name);
+    replacement_text.push_str(": ");
+    match (self_param.amp_token(), self_param.mut_token()) {
+        (Some(_), None) => replacement_text.push('&'),
+        (Some(_), Some(_)) => replacement_text.push_str("&mut "),
+        (_, _) => (),
+    };
+    replacement_text.push_str(type_name.as_str());
+
+    Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
+}
+
+fn source_edit_from_references(
+    references: &[FileReference],
     def: Definition,
     new_name: &str,
-) -> RenameResult<SourceChange> {
-    let ident_kind = check_identifier(new_name)?;
-
-    let def_is_lbl_or_lt = matches!(
-        def,
-        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
-    );
-    match (ident_kind, def) {
-        (IdentifierKind::ToSelf, _)
-        | (IdentifierKind::Underscore, _)
-        | (IdentifierKind::Ident, _)
-            if def_is_lbl_or_lt =>
-        {
-            mark::hit!(rename_not_a_lifetime_ident_ref);
-            bail!("Invalid name `{}`: not a lifetime identifier", new_name)
-        }
-        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => mark::hit!(rename_lifetime),
-        (IdentifierKind::Lifetime, _) => {
-            mark::hit!(rename_not_an_ident_ref);
-            bail!("Invalid name `{}`: not an identifier", new_name)
-        }
-        (IdentifierKind::ToSelf, Definition::Local(local)) if local.is_self(sema.db) => {
-            // no-op
-            mark::hit!(rename_self_to_self);
-            return Ok(SourceChange::default());
-        }
-        (ident_kind, Definition::Local(local)) if local.is_self(sema.db) => {
-            mark::hit!(rename_self_to_param);
-            return rename_self_to_param(sema, local, new_name, ident_kind);
-        }
-        (IdentifierKind::ToSelf, Definition::Local(local)) => {
-            mark::hit!(rename_to_self);
-            return rename_to_self(sema, local);
+) -> TextEdit {
+    let mut edit = TextEdit::builder();
+    for reference in references {
+        let (range, replacement) = match &reference.name {
+            // if the ranges differ then the node is inside a macro call, we can't really attempt
+            // to make special rewrites like shorthand syntax and such, so just rename the node in
+            // the macro input
+            ast::NameLike::NameRef(name_ref)
+                if name_ref.syntax().text_range() == reference.range =>
+            {
+                source_edit_from_name_ref(name_ref, new_name, def)
+            }
+            ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
+                source_edit_from_name(name, new_name)
+            }
+            _ => None,
         }
-        (IdentifierKind::ToSelf, _) => bail!("Invalid name `{}`: not an identifier", new_name),
-        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
+        .unwrap_or_else(|| (reference.range, new_name.to_string()));
+        edit.replace(range, replacement);
     }
+    edit.finish()
+}
 
-    let usages = def.usages(sema).all();
-    if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
-        mark::hit!(rename_underscore_multiple);
-        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
+    if let Some(_) = ast::RecordPatField::for_field_name(name) {
+        if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
+            return Some((
+                TextRange::empty(ident_pat.syntax().text_range().start()),
+                [new_name, ": "].concat(),
+            ));
+        }
     }
-    let mut source_change = SourceChange::default();
-    source_change.extend(usages.iter().map(|(&file_id, references)| {
-        source_edit_from_references(sema, file_id, &references, def, new_name)
-    }));
+    None
+}
 
-    let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
-    source_change.insert_source_edit(file_id, edit);
-    Ok(source_change)
+fn source_edit_from_name_ref(
+    name_ref: &ast::NameRef,
+    new_name: &str,
+    def: Definition,
+) -> Option<(TextRange, String)> {
+    if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
+        let rcf_name_ref = record_field.name_ref();
+        let rcf_expr = record_field.expr();
+        match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
+            // field: init-expr, check if we can use a field init shorthand
+            (Some(field_name), Some(init)) => {
+                if field_name == *name_ref {
+                    if init.text() == new_name {
+                        mark::hit!(test_rename_field_put_init_shorthand);
+                        // same names, we can use a shorthand here instead.
+                        // we do not want to erase attributes hence this range start
+                        let s = field_name.syntax().text_range().start();
+                        let e = record_field.syntax().text_range().end();
+                        return Some((TextRange::new(s, e), new_name.to_owned()));
+                    }
+                } else if init == *name_ref {
+                    if field_name.text() == new_name {
+                        mark::hit!(test_rename_local_put_init_shorthand);
+                        // same names, we can use a shorthand here instead.
+                        // we do not want to erase attributes hence this range start
+                        let s = field_name.syntax().text_range().start();
+                        let e = record_field.syntax().text_range().end();
+                        return Some((TextRange::new(s, e), new_name.to_owned()));
+                    }
+                }
+                None
+            }
+            // init shorthand
+            // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
+            // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
+            (None, Some(_)) if matches!(def, Definition::Field(_)) => {
+                mark::hit!(test_rename_field_in_field_shorthand);
+                let s = name_ref.syntax().text_range().start();
+                Some((TextRange::empty(s), format!("{}: ", new_name)))
+            }
+            (None, Some(_)) if matches!(def, Definition::Local(_)) => {
+                mark::hit!(test_rename_local_in_field_shorthand);
+                let s = name_ref.syntax().text_range().end();
+                Some((TextRange::empty(s), format!(": {}", new_name)))
+            }
+            _ => None,
+        }
+    } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
+        let rcf_name_ref = record_field.name_ref();
+        let rcf_pat = record_field.pat();
+        match (rcf_name_ref, rcf_pat) {
+            // field: rename
+            (Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
+                // field name is being renamed
+                if pat.name().map_or(false, |it| it.text() == new_name) {
+                    mark::hit!(test_rename_field_put_init_shorthand_pat);
+                    // same names, we can use a shorthand here instead/
+                    // we do not want to erase attributes hence this range start
+                    let s = field_name.syntax().text_range().start();
+                    let e = record_field.syntax().text_range().end();
+                    Some((TextRange::new(s, e), pat.to_string()))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    } else {
+        None
+    }
 }
 
 fn source_edit_from_def(
diff --git a/crates/ide_assists/src/handlers/apply_demorgan.rs b/crates/ide_assists/src/handlers/apply_demorgan.rs
index 6997ea048..128b1eb56 100644
--- a/crates/ide_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ide_assists/src/handlers/apply_demorgan.rs
@@ -1,4 +1,5 @@
 use syntax::ast::{self, AstNode};
+use test_utils::mark;
 
 use crate::{utils::invert_boolean_expression, AssistContext, AssistId, AssistKind, Assists};
 
@@ -43,9 +44,36 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
         "Apply De Morgan's law",
         op_range,
         |edit| {
+            let paren_expr = expr.syntax().parent().and_then(|parent| ast::ParenExpr::cast(parent));
+
+            let neg_expr = paren_expr
+                .clone()
+                .and_then(|paren_expr| paren_expr.syntax().parent())
+                .and_then(|parent| ast::PrefixExpr::cast(parent))
+                .and_then(|prefix_expr| {
+                    if prefix_expr.op_kind().unwrap() == ast::PrefixOp::Not {
+                        Some(prefix_expr)
+                    } else {
+                        None
+                    }
+                });
+
             edit.replace(op_range, opposite_op);
-            edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
-            edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+
+            if let Some(paren_expr) = paren_expr {
+                edit.replace(lhs_range, not_lhs.syntax().text());
+                edit.replace(rhs_range, not_rhs.syntax().text());
+                if let Some(neg_expr) = neg_expr {
+                    mark::hit!(demorgan_double_negation);
+                    edit.replace(neg_expr.op_token().unwrap().text_range(), "");
+                } else {
+                    mark::hit!(demorgan_double_parens);
+                    edit.replace(paren_expr.l_paren_token().unwrap().text_range(), "!(");
+                }
+            } else {
+                edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
+                edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+            }
         },
     )
 }
@@ -62,6 +90,7 @@ fn opposite_logic_op(kind: ast::BinOp) -> Option<&'static str> {
 #[cfg(test)]
 mod tests {
     use ide_db::helpers::FamousDefs;
+    use test_utils::mark;
 
     use super::*;
 
@@ -156,4 +185,16 @@ fn f() {
     fn demorgan_doesnt_apply_with_cursor_not_on_op() {
         check_assist_not_applicable(apply_demorgan, "fn f() { $0 !x || !x }")
     }
+
+    #[test]
+    fn demorgan_doesnt_double_negation() {
+        mark::check!(demorgan_double_negation);
+        check_assist(apply_demorgan, "fn f() { !(x ||$0 x) }", "fn f() { (!x && !x) }")
+    }
+
+    #[test]
+    fn demorgan_doesnt_double_parens() {
+        mark::check!(demorgan_double_parens);
+        check_assist(apply_demorgan, "fn f() { (x ||$0 x) }", "fn f() { !(!x && !x) }")
+    }
 }
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index 3a5bc4381..cb05e85fc 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -39,7 +39,8 @@ pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
 }
 
 fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
-    for attr_completion in ATTRIBUTES {
+    let is_inner = attribute.kind() == ast::AttrKind::Inner;
+    for attr_completion in ATTRIBUTES.iter().filter(|compl| is_inner || !compl.prefer_inner) {
         let mut item = CompletionItem::new(
             CompletionKind::Attribute,
             ctx.source_range(),
diff --git a/crates/ide_completion/src/completions/fn_param.rs b/crates/ide_completion/src/completions/fn_param.rs
index 38e33a93e..1bcc8727f 100644
--- a/crates/ide_completion/src/completions/fn_param.rs
+++ b/crates/ide_completion/src/completions/fn_param.rs
@@ -25,9 +25,12 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
             return;
         }
         func.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
-            let text = param.syntax().text().to_string();
-            params.entry(text).or_insert(param);
-        })
+            if let Some(pat) = param.pat() {
+                let text = param.syntax().text().to_string();
+                let lookup = pat.syntax().text().to_string();
+                params.entry(text).or_insert(lookup);
+            }
+        });
     };
 
     for node in ctx.token.parent().ancestors() {
@@ -50,18 +53,12 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
         };
     }
 
-    params
-        .into_iter()
-        .filter_map(|(label, param)| {
-            let lookup = param.pat()?.syntax().text().to_string();
-            Some((label, lookup))
-        })
-        .for_each(|(label, lookup)| {
-            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
-                .kind(CompletionItemKind::Binding)
-                .lookup_by(lookup)
-                .add_to(acc)
-        });
+    params.into_iter().for_each(|(label, lookup)| {
+        CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+            .kind(CompletionItemKind::Binding)
+            .lookup_by(lookup)
+            .add_to(acc)
+    });
 }
 
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index eb81f9765..03c6dd454 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -1,5 +1,7 @@
 //! Completes keywords.
 
+use std::iter;
+
 use syntax::SyntaxKind;
 use test_utils::mark;
 
@@ -19,10 +21,14 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
         CompletionItem::new(CompletionKind::Keyword, source_range, "self")
             .kind(CompletionItemKind::Keyword)
             .add_to(acc);
-        CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
-            .kind(CompletionItemKind::Keyword)
-            .insert_text("super::")
-            .add_to(acc);
+        if iter::successors(ctx.path_qual.clone(), |p| p.qualifier())
+            .all(|p| p.segment().and_then(|s| s.super_token()).is_some())
+        {
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
+                .kind(CompletionItemKind::Keyword)
+                .insert_text("super::")
+                .add_to(acc);
+        }
     }
 
     // Suggest .await syntax for types that implement Future trait
@@ -85,6 +91,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     if ctx.is_expr {
         add_keyword(ctx, acc, "match", "match $0 {}");
         add_keyword(ctx, acc, "while", "while $0 {}");
+        add_keyword(ctx, acc, "while let", "while let $1 = $0 {}");
         add_keyword(ctx, acc, "loop", "loop {$0}");
         add_keyword(ctx, acc, "if", "if $0 {}");
         add_keyword(ctx, acc, "if let", "if let $1 = $0 {}");
@@ -204,9 +211,17 @@ mod tests {
             "#]],
         );
 
+        // FIXME: `self` shouldn't be shown here and the check below
         check(
             r"use a::$0",
             expect![[r#"
+            kw self
+        "#]],
+        );
+
+        check(
+            r"use super::$0",
+            expect![[r#"
                 kw self
                 kw super::
             "#]],
@@ -215,9 +230,8 @@ mod tests {
         check(
             r"use a::{b, $0}",
             expect![[r#"
-                kw self
-                kw super::
-            "#]],
+            kw self
+        "#]],
         );
     }
 
@@ -256,6 +270,7 @@ mod tests {
                 kw trait
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
@@ -283,6 +298,7 @@ mod tests {
                 kw trait
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
@@ -310,6 +326,7 @@ mod tests {
                 kw trait
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
@@ -344,6 +361,7 @@ fn quux() -> i32 {
             expect![[r#"
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
@@ -393,6 +411,7 @@ fn quux() -> i32 {
                 kw trait
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
@@ -552,6 +571,7 @@ pub mod future {
             expect![[r#"
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
@@ -611,6 +631,7 @@ fn foo() {
             expect![[r#"
                 kw match
                 kw while
+                kw while let
                 kw loop
                 kw if
                 kw if let
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index 2afa6979e..72fb757b1 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -81,9 +81,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                         return None;
                     }
                     match item {
-                        hir::AssocItem::Function(func) => {
-                            acc.add_function(ctx, func, None);
-                        }
+                        hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
                         hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
                         hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
                     }
@@ -110,9 +108,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     continue;
                 }
                 match item {
-                    hir::AssocItem::Function(func) => {
-                        acc.add_function(ctx, func, None);
-                    }
+                    hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
                     hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
                     hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
                 }
@@ -143,9 +139,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     // them.
                     if seen.insert(item) {
                         match item {
-                            hir::AssocItem::Function(func) => {
-                                acc.add_function(ctx, func, None);
-                            }
+                            hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
                             hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
                             hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
                         }
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index d836c5d1a..9ee3a8586 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.10.0"
 rowan = "0.12.2"
-rustc_lexer = { version = "708.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "709.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"