63 files changed, 2053 insertions, 1189 deletions
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 81f999090..5aab5fb8b 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,5 +1,4 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-use either::Either;
 use hir::{InFile, SourceAnalyzer, SourceBinder};
 use ra_db::{FileRange, SourceDatabase};
 use ra_fmt::{leading_indent, reindent};
@@ -11,12 +10,36 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
-use crate::{AssistAction, AssistId, AssistLabel, ResolvedAssist};
+use crate::{AssistAction, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
 #[derive(Clone, Debug)]
-pub(crate) enum Assist {
+pub(crate) struct Assist(pub(crate) Vec<AssistInfo>);
-    Unresolved { label: AssistLabel },
-    Resolved { assist: ResolvedAssist },
+#[derive(Clone, Debug)]
+pub(crate) struct AssistInfo {
+    pub(crate) label: AssistLabel,
+    pub(crate) group_label: Option<GroupLabel>,
+    pub(crate) action: Option<AssistAction>,
+}
+impl AssistInfo {
+    fn new(label: AssistLabel) -> AssistInfo {
+        AssistInfo { label, group_label: None, action: None }
+    }
+    fn resolved(self, action: AssistAction) -> AssistInfo {
+        AssistInfo { action: Some(action), ..self }
+    }
+    fn with_group(self, group_label: GroupLabel) -> AssistInfo {
+        AssistInfo { group_label: Some(group_label), ..self }
+    }
+    pub(crate) fn into_resolved(self) -> Option<ResolvedAssist> {
+        let label = self.label;
+        let group_label = self.group_label;
+        self.action.map(|action| ResolvedAssist { label, group_label, action })
+    }
 }
 pub(crate) type AssistHandler = fn(AssistCtx) -> Option<Assist>;
@@ -84,44 +107,21 @@ impl<'a> AssistCtx<'a> {
    ) -> Option<Assist> {
        let label = AssistLabel::new(label.into(), id);
-        let assist = if self.should_compute_edit {
+        let mut info = AssistInfo::new(label);
+        if self.should_compute_edit {
            let action = {
                let mut edit = ActionBuilder::default();
                f(&mut edit);
                edit.build()
            };
-            Assist::Resolved { assist: ResolvedAssist { label, action_data: Either::Left(action) } }
+            info = info.resolved(action)
-        } else {
-            Assist::Unresolved { label }
        };
-        Some(assist)
+        Some(Assist(vec![info]))
    }
-    pub(crate) fn add_assist_group(
+    pub(crate) fn add_assist_group(self, group_name: impl Into<String>) -> AssistGroup<'a> {
-        self,
+        AssistGroup { ctx: self, group_name: group_name.into(), assists: Vec::new() }
-        id: AssistId,
-        label: impl Into<String>,
-        f: impl FnOnce() -> Vec<ActionBuilder>,
-    ) -> Option<Assist> {
-        let label = AssistLabel::new(label.into(), id);
-        let assist = if self.should_compute_edit {
-            let actions = f();
-            assert!(!actions.is_empty(), "Assist cannot have no");
-            Assist::Resolved {
-                assist: ResolvedAssist {
-                    label,
-                    action_data: Either::Right(
-                        actions.into_iter().map(ActionBuilder::build).collect(),
-                    ),
-                },
-            }
-        } else {
-            Assist::Unresolved { label }
-        };
-        Some(assist)
    }
    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
@@ -155,20 +155,48 @@ impl<'a> AssistCtx<'a> {
    }
 }
+pub(crate) struct AssistGroup<'a> {
+    ctx: AssistCtx<'a>,
+    group_name: String,
+    assists: Vec<AssistInfo>,
+}
+impl<'a> AssistGroup<'a> {
+    pub(crate) fn add_assist(
+        &mut self,
+        id: AssistId,
+        label: impl Into<String>,
+        f: impl FnOnce(&mut ActionBuilder),
+    ) {
+        let label = AssistLabel::new(label.into(), id);
+        let mut info = AssistInfo::new(label).with_group(GroupLabel(self.group_name.clone()));
+        if self.ctx.should_compute_edit {
+            let action = {
+                let mut edit = ActionBuilder::default();
+                f(&mut edit);
+                edit.build()
+            };
+            info = info.resolved(action)
+        };
+        self.assists.push(info)
+    }
+    pub(crate) fn finish(self) -> Option<Assist> {
+        assert!(!self.assists.is_empty());
+        Some(Assist(self.assists))
+    }
+}
 #[derive(Default)]
 pub(crate) struct ActionBuilder {
    edit: TextEditBuilder,
    cursor_position: Option<TextUnit>,
    target: Option<TextRange>,
-    label: Option<String>,
 }
 impl ActionBuilder {
-    /// Adds a custom label to the action, if it needs to be different from the assist label
-    pub(crate) fn label(&mut self, label: impl Into<String>) {
-        self.label = Some(label.into())
-    }
    /// Replaces specified `range` of text with a given string.
    pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
        self.edit.replace(range, replace_with.into())
@@ -227,7 +255,6 @@ impl ActionBuilder {
            edit: self.edit.finish(),
            cursor_position: self.cursor_position,
            target: self.target,
-            label: self.label,
        }
    }
 }
diff --git a/crates/ra_assists/src/doc_tests.rs b/crates/ra_assists/src/doc_tests.rs
index ae0e5605c..c0f9bc1fb 100644
--- a/crates/ra_assists/src/doc_tests.rs
+++ b/crates/ra_assists/src/doc_tests.rs
@@ -30,6 +30,6 @@ fn check(assist_id: &str, before: &str, after: &str) {
            )
        });
-    let actual = assist.get_first_action().edit.apply(&before);
+    let actual = assist.action.edit.apply(&before);
    assert_eq_text!(after, &actual);
 }
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 0d95b957b..4ab09b167 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 use super::check;
@@ -161,21 +161,6 @@ impl Trait<u32> for () {
 }
 #[test]
-fn doctest_add_import() {
-    check(
-        "add_import",
-        r#####"
-fn process(map: std::collections::<|>HashMap<String, String>) {}
-"#####,
-        r#####"
-use std::collections::HashMap;
-fn process(map: HashMap<String, String>) {}
-"#####,
-    )
-}
-#[test]
 fn doctest_add_new() {
    check(
        "add_new",
@@ -592,6 +577,21 @@ fn handle(action: Action) {
 }
 #[test]
+fn doctest_replace_qualified_name_with_use() {
+    check(
+        "replace_qualified_name_with_use",
+        r#####"
+fn process(map: std::collections::<|>HashMap<String, String>) {}
+"#####,
+        r#####"
+use std::collections::HashMap;
+fn process(map: HashMap<String, String>) {}
+"#####,
+    )
+}
+#[test]
 fn doctest_split_import() {
    check(
        "split_import",
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index a08639311..2701eddb8 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::InFile;
+use hir::{Adt, InFile};
 use join_to_string::join;
 use ra_syntax::{
    ast::{
@@ -135,16 +135,22 @@ fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<a
    })?;
    let mut sb = ctx.source_binder();
-    let struct_ty = {
+    let struct_def = {
        let src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        sb.to_def(src)?.ty(db)
+        sb.to_def(src)?
    };
    let block = module.descendants().filter_map(ast::ImplBlock::cast).find_map(|impl_blk| {
        let src = InFile { file_id: ctx.frange.file_id.into(), value: impl_blk.clone() };
        let blk = sb.to_def(src)?;
-        let same_ty = blk.target_ty(db) == struct_ty;
+        // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
+        // (we currently use the wrong type parameter)
+        // also we wouldn't want to use e.g. `impl S<u32>`
+        let same_ty = match blk.target_ty(db).as_adt() {
+            Some(def) => def == Adt::Struct(struct_def),
+            None => false,
+        };
        let not_trait_impl = blk.target_trait(db).is_none();
        if !(same_ty && not_trait_impl) {
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 84b5474f9..1fb701da5 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -1,13 +1,9 @@
-use hir::ModPath;
 use ra_ide_db::imports_locator::ImportsLocator;
-use ra_syntax::{
+use ra_syntax::ast::{self, AstNode};
-    ast::{self, AstNode},
-    SyntaxNode,
-};
 use crate::{
-    assist_ctx::{ActionBuilder, Assist, AssistCtx},
+    assist_ctx::{Assist, AssistCtx},
-    auto_import_text_edit, AssistId,
+    insert_use_statement, AssistId,
 };
 use std::collections::BTreeSet;
@@ -31,31 +27,34 @@ use std::collections::BTreeSet;
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
 pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
-    let path_to_import: ast::Path = ctx.find_node_at_offset()?;
+    let path_under_caret: ast::Path = ctx.find_node_at_offset()?;
-    let path_to_import_syntax = path_to_import.syntax();
+    if path_under_caret.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
-    if path_to_import_syntax.ancestors().find_map(ast::UseItem::cast).is_some() {
        return None;
    }
-    let name_to_import =
-        path_to_import_syntax.descendants().find_map(ast::NameRef::cast)?.syntax().to_string();
-    let module = path_to_import_syntax.ancestors().find_map(ast::Module::cast);
+    let module = path_under_caret.syntax().ancestors().find_map(ast::Module::cast);
    let position = match module.and_then(|it| it.item_list()) {
        Some(item_list) => item_list.syntax().clone(),
        None => {
-            let current_file = path_to_import_syntax.ancestors().find_map(ast::SourceFile::cast)?;
+            let current_file =
+                path_under_caret.syntax().ancestors().find_map(ast::SourceFile::cast)?;
            current_file.syntax().clone()
        }
    };
    let source_analyzer = ctx.source_analyzer(&position, None);
    let module_with_name_to_import = source_analyzer.module()?;
-    if source_analyzer.resolve_path(ctx.db, &path_to_import).is_some() {
+    let name_ref_to_import =
+        path_under_caret.syntax().descendants().find_map(ast::NameRef::cast)?;
+    if source_analyzer
+        .resolve_path(ctx.db, &name_ref_to_import.syntax().ancestors().find_map(ast::Path::cast)?)
+        .is_some()
+    {
        return None;
    }
-    let mut imports_locator = ImportsLocator::new(ctx.db);
+    let name_to_import = name_ref_to_import.syntax().to_string();
+    let proposed_imports = ImportsLocator::new(ctx.db)
-    let proposed_imports = imports_locator
        .find_imports(&name_to_import)
        .into_iter()
        .filter_map(|module_def| module_with_name_to_import.find_use_path(ctx.db, module_def))
@@ -67,24 +66,24 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
        return None;
    }
-    ctx.add_assist_group(AssistId("auto_import"), format!("Import {}", name_to_import), || {
+    let mut group = ctx.add_assist_group(format!("Import {}", name_to_import));
-        proposed_imports
+    for import in proposed_imports {
-            .into_iter()
+        group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
-            .map(|import| import_to_action(import, &position, &path_to_import_syntax))
+            edit.target(path_under_caret.syntax().text_range());
-            .collect()
+            insert_use_statement(
-    })
+                &position,
-}
+                path_under_caret.syntax(),
+                &import,
-fn import_to_action(import: ModPath, position: &SyntaxNode, anchor: &SyntaxNode) -> ActionBuilder {
+                edit.text_edit_builder(),
-    let mut action_builder = ActionBuilder::default();
+            );
-    action_builder.label(format!("Import `{}`", &import));
+        });
-    auto_import_text_edit(position, anchor, &import, action_builder.text_edit_builder());
+    }
-    action_builder
+    group.finish()
 }
 #[cfg(test)]
 mod tests {
-    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
    use super::*;
@@ -255,4 +254,40 @@ mod tests {
            ",
        );
    }
+    #[test]
+    fn auto_import_target() {
+        check_assist_target(
+            auto_import,
+            r"
+            struct AssistInfo {
+                group_label: Option<<|>GroupLabel>,
+            }
+            mod m { pub struct GroupLabel; }
+            ",
+            "GroupLabel",
+        )
+    }
+    #[test]
+    fn not_applicable_when_path_start_is_imported() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            pub mod mod1 {
+                pub mod mod2 {
+                    pub mod mod3 {
+                        pub struct TestStruct;
+                    }
+                }
+            }
+            use mod1::mod2;
+            fn main() {
+                mod2::mod3::TestStruct<|>
+            }
+            ",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 0908fc246..ae2437ed3 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -75,10 +75,10 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
 }
 fn is_trivial(arm: &ast::MatchArm) -> bool {
-    arm.pats().any(|pat| match pat {
+    match arm.pat() {
-        ast::Pat::PlaceholderPat(..) => true,
+        Some(ast::Pat::PlaceholderPat(..)) => true,
        _ => false,
-    })
+    }
 }
 fn resolve_enum_def(
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index 670614dd8..b2a194cb5 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -75,7 +75,7 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
        } else {
            arms_to_merge
                .iter()
-                .flat_map(ast::MatchArm::pats)
+                .filter_map(ast::MatchArm::pat)
                .map(|x| x.syntax().to_string())
                .collect::<Vec<String>>()
                .join(" | ")
@@ -96,10 +96,10 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
 }
 fn contains_placeholder(a: &ast::MatchArm) -> bool {
-    a.pats().any(|x| match x {
+    match a.pat() {
-        ra_syntax::ast::Pat::PlaceholderPat(..) => true,
+        Some(ra_syntax::ast::Pat::PlaceholderPat(..)) => true,
        _ => false,
-    })
+    }
 }
 fn next_arm(arm: &ast::MatchArm) -> Option<ast::MatchArm> {
diff --git a/crates/ra_assists/src/handlers/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index 2b91ce7c4..a61a2ba3e 100644
--- a/crates/ra_assists/src/handlers/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -90,7 +90,7 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx) -> Option<Assist> {
 // ```
 pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
    let match_arm: MatchArm = ctx.find_node_at_offset::<MatchArm>()?;
-    let last_match_pat = match_arm.pats().last()?;
+    let match_pat = match_arm.pat()?;
    let arm_body = match_arm.expr()?;
    let if_expr: IfExpr = IfExpr::cast(arm_body.syntax().clone())?;
@@ -122,8 +122,8 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
                _ => edit.replace(if_expr.syntax().text_range(), then_block.syntax().text()),
            }
-            edit.insert(last_match_pat.syntax().text_range().end(), buf);
+            edit.insert(match_pat.syntax().text_range().end(), buf);
-            edit.set_cursor(last_match_pat.syntax().text_range().end() + TextUnit::from(1));
+            edit.set_cursor(match_pat.syntax().text_range().end() + TextUnit::from(1));
        },
    )
 }
diff --git a/crates/ra_assists/src/handlers/add_import.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index f03dddac8..b70c88ec2 100644
--- a/crates/ra_assists/src/handlers/add_import.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -12,10 +12,10 @@ use crate::{
    AssistId,
 };
-/// This function produces sequence of text edits into edit
+/// Creates and inserts a use statement for the given path to import.
-/// to import the target path in the most appropriate scope given
+/// The use statement is inserted in the scope most appropriate to the
-/// the cursor position
+/// the cursor position given, additionally merged with the existing use imports.
-pub fn auto_import_text_edit(
+pub fn insert_use_statement(
    // Ideally the position of the cursor, used to
    position: &SyntaxNode,
    // The statement to use as anchor (last resort)
@@ -37,9 +37,9 @@ pub fn auto_import_text_edit(
    }
 }
-// Assist: add_import
+// Assist: replace_qualified_name_with_use
 //
-// Adds a use statement for a given fully-qualified path.
+// Adds a use statement for a given fully-qualified name.
 //
 // ```
 // fn process(map: std::collections::<|>HashMap<String, String>) {}
@@ -50,7 +50,7 @@ pub fn auto_import_text_edit(
 //
 // fn process(map: HashMap<String, String>) {}
 // ```
-pub(crate) fn add_import(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist> {
    let path: ast::Path = ctx.find_node_at_offset()?;
    // We don't want to mess with use statements
    if path.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
@@ -72,9 +72,13 @@ pub(crate) fn add_import(ctx: AssistCtx) -> Option<Assist> {
        }
    };
-    ctx.add_assist(AssistId("add_import"), format!("Import {}", fmt_segments(&segments)), |edit| {
+    ctx.add_assist(
-        apply_auto_import(&position, &path, &segments, edit.text_edit_builder());
+        AssistId("replace_qualified_name_with_use"),
-    })
+        "Replace qualified path with use",
+        |edit| {
+            replace_with_use(&position, &path, &segments, edit.text_edit_builder());
+        },
+    )
 }
 fn collect_path_segments_raw(
@@ -107,12 +111,6 @@ fn collect_path_segments_raw(
    Some(segments.len() - oldlen)
 }
-fn fmt_segments(segments: &[SmolStr]) -> String {
-    let mut buf = String::new();
-    fmt_segments_raw(segments, &mut buf);
-    buf
-}
 fn fmt_segments_raw(segments: &[SmolStr], buf: &mut String) {
    let mut iter = segments.iter();
    if let Some(s) = iter.next() {
@@ -558,7 +556,7 @@ fn make_assist_add_nested_import(
    }
 }
-fn apply_auto_import(
+fn replace_with_use(
    container: &SyntaxNode,
    path: &ast::Path,
    target: &[SmolStr],
@@ -567,7 +565,7 @@ fn apply_auto_import(
    let action = best_action_for_target(container.clone(), path.syntax().clone(), target);
    make_assist(&action, target, edit);
    if let Some(last) = path.segment() {
-        // Here we are assuming the assist will provide a  correct use statement
+        // Here we are assuming the assist will provide a correct use statement
        // so we can delete the path qualifier
        edit.delete(TextRange::from_to(
            path.syntax().text_range().start(),
@@ -603,9 +601,9 @@ mod tests {
    use super::*;
    #[test]
-    fn test_auto_import_add_use_no_anchor() {
+    fn test_replace_add_use_no_anchor() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 std::fmt::Debug<|>
    ",
@@ -617,9 +615,9 @@ Debug<|>
        );
    }
    #[test]
-    fn test_auto_import_add_use_no_anchor_with_item_below() {
+    fn test_replace_add_use_no_anchor_with_item_below() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 std::fmt::Debug<|>
@@ -638,9 +636,9 @@ fn main() {
    }
    #[test]
-    fn test_auto_import_add_use_no_anchor_with_item_above() {
+    fn test_replace_add_use_no_anchor_with_item_above() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 fn main() {
 }
@@ -659,9 +657,9 @@ Debug<|>
    }
    #[test]
-    fn test_auto_import_add_use_no_anchor_2seg() {
+    fn test_replace_add_use_no_anchor_2seg() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 std::fmt<|>::Debug
    ",
@@ -674,9 +672,9 @@ fmt<|>::Debug
    }
    #[test]
-    fn test_auto_import_add_use() {
+    fn test_replace_add_use() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use stdx;
@@ -694,9 +692,9 @@ impl Debug<|> for Foo {
    }
    #[test]
-    fn test_auto_import_file_use_other_anchor() {
+    fn test_replace_file_use_other_anchor() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 impl std::fmt::Debug<|> for Foo {
 }
@@ -711,9 +709,9 @@ impl Debug<|> for Foo {
    }
    #[test]
-    fn test_auto_import_add_use_other_anchor_indent() {
+    fn test_replace_add_use_other_anchor_indent() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
    impl std::fmt::Debug<|> for Foo {
    }
@@ -728,9 +726,9 @@ impl Debug<|> for Foo {
    }
    #[test]
-    fn test_auto_import_split_different() {
+    fn test_replace_split_different() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt;
@@ -747,9 +745,9 @@ impl io<|> for Foo {
    }
    #[test]
-    fn test_auto_import_split_self_for_use() {
+    fn test_replace_split_self_for_use() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt;
@@ -766,9 +764,9 @@ impl Debug<|> for Foo {
    }
    #[test]
-    fn test_auto_import_split_self_for_target() {
+    fn test_replace_split_self_for_target() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt::Debug;
@@ -785,9 +783,9 @@ impl fmt<|> for Foo {
    }
    #[test]
-    fn test_auto_import_add_to_nested_self_nested() {
+    fn test_replace_add_to_nested_self_nested() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt::{Debug, nested::{Display}};
@@ -804,9 +802,9 @@ impl nested<|> for Foo {
    }
    #[test]
-    fn test_auto_import_add_to_nested_self_already_included() {
+    fn test_replace_add_to_nested_self_already_included() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt::{Debug, nested::{self, Display}};
@@ -823,9 +821,9 @@ impl nested<|> for Foo {
    }
    #[test]
-    fn test_auto_import_add_to_nested_nested() {
+    fn test_replace_add_to_nested_nested() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt::{Debug, nested::{Display}};
@@ -842,9 +840,9 @@ impl Debug<|> for Foo {
    }
    #[test]
-    fn test_auto_import_split_common_target_longer() {
+    fn test_replace_split_common_target_longer() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt::Debug;
@@ -861,9 +859,9 @@ impl Display<|> for Foo {
    }
    #[test]
-    fn test_auto_import_split_common_use_longer() {
+    fn test_replace_split_common_use_longer() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt::nested::Debug;
@@ -880,9 +878,9 @@ impl Display<|> for Foo {
    }
    #[test]
-    fn test_auto_import_use_nested_import() {
+    fn test_replace_use_nested_import() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use crate::{
    ty::{Substs, Ty},
@@ -903,9 +901,9 @@ fn foo() { lower<|>::trait_env() }
    }
    #[test]
-    fn test_auto_import_alias() {
+    fn test_replace_alias() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt as foo;
@@ -922,9 +920,9 @@ impl Debug<|> for Foo {
    }
    #[test]
-    fn test_auto_import_not_applicable_one_segment() {
+    fn test_replace_not_applicable_one_segment() {
        check_assist_not_applicable(
-            add_import,
+            replace_qualified_name_with_use,
            "
 impl foo<|> for Foo {
 }
@@ -933,9 +931,9 @@ impl foo<|> for Foo {
    }
    #[test]
-    fn test_auto_import_not_applicable_in_use() {
+    fn test_replace_not_applicable_in_use() {
        check_assist_not_applicable(
-            add_import,
+            replace_qualified_name_with_use,
            "
 use std::fmt<|>;
 ",
@@ -943,9 +941,9 @@ use std::fmt<|>;
    }
    #[test]
-    fn test_auto_import_add_use_no_anchor_in_mod_mod() {
+    fn test_replace_add_use_no_anchor_in_mod_mod() {
        check_assist(
-            add_import,
+            replace_qualified_name_with_use,
            "
 mod foo {
    mod bar {
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index eca6dec4b..828a8e9e8 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -12,16 +12,13 @@ mod doc_tests;
 mod utils;
 pub mod ast_transform;
-use std::cmp::Ordering;
-use either::Either;
 use ra_db::FileRange;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{TextRange, TextUnit};
 use ra_text_edit::TextEdit;
 pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
-pub use crate::handlers::add_import::auto_import_text_edit;
+pub use crate::handlers::replace_qualified_name_with_use::insert_use_statement;
 /// Unique identifier of the assist, should not be shown to the user
 /// directly.
@@ -35,6 +32,9 @@ pub struct AssistLabel {
    pub id: AssistId,
 }
+#[derive(Clone, Debug)]
+pub struct GroupLabel(pub String);
 impl AssistLabel {
    pub(crate) fn new(label: String, id: AssistId) -> AssistLabel {
        // FIXME: make fields private, so that this invariant can't be broken
@@ -45,7 +45,6 @@ impl AssistLabel {
 #[derive(Debug, Clone)]
 pub struct AssistAction {
-    pub label: Option<String>,
    pub edit: TextEdit,
    pub cursor_position: Option<TextUnit>,
    // FIXME: This belongs to `AssistLabel`
@@ -55,16 +54,8 @@ pub struct AssistAction {
 #[derive(Debug, Clone)]
 pub struct ResolvedAssist {
    pub label: AssistLabel,
-    pub action_data: Either<AssistAction, Vec<AssistAction>>,
+    pub group_label: Option<GroupLabel>,
-}
+    pub action: AssistAction,
-impl ResolvedAssist {
-    pub fn get_first_action(&self) -> AssistAction {
-        match &self.action_data {
-            Either::Left(action) => action.clone(),
-            Either::Right(actions) => actions[0].clone(),
-        }
-    }
 }
 /// Return all the assists applicable at the given position.
@@ -76,10 +67,8 @@ pub fn unresolved_assists(db: &RootDatabase, range: FileRange) -> Vec<AssistLabe
    handlers::all()
        .iter()
        .filter_map(|f| f(ctx.clone()))
-        .map(|a| match a {
+        .flat_map(|it| it.0)
-            Assist::Unresolved { label } => label,
+        .map(|a| a.label)
-            Assist::Resolved { .. } => unreachable!(),
-        })
        .collect()
 }
@@ -92,24 +81,13 @@ pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssi
    let mut a = handlers::all()
        .iter()
        .filter_map(|f| f(ctx.clone()))
-        .map(|a| match a {
+        .flat_map(|it| it.0)
-            Assist::Resolved { assist } => assist,
+        .map(|it| it.into_resolved().unwrap())
-            Assist::Unresolved { .. } => unreachable!(),
-        })
        .collect::<Vec<_>>();
-    sort_assists(&mut a);
+    a.sort_by_key(|it| it.action.target.map_or(TextUnit::from(!0u32), |it| it.len()));
    a
 }
-fn sort_assists(assists: &mut [ResolvedAssist]) {
-    assists.sort_by(|a, b| match (a.get_first_action().target, b.get_first_action().target) {
-        (Some(a), Some(b)) => a.len().cmp(&b.len()),
-        (Some(_), None) => Ordering::Less,
-        (None, Some(_)) => Ordering::Greater,
-        (None, None) => Ordering::Equal,
-    });
-}
 mod handlers {
    use crate::AssistHandler;
@@ -133,7 +111,7 @@ mod handlers {
    mod replace_if_let_with_match;
    mod split_import;
    mod remove_dbg;
-    pub(crate) mod add_import;
+    pub(crate) mod replace_qualified_name_with_use;
    mod add_missing_impl_members;
    mod move_guard;
    mod move_bounds;
@@ -158,7 +136,7 @@ mod handlers {
            replace_if_let_with_match::replace_if_let_with_match,
            split_import::split_import,
            remove_dbg::remove_dbg,
-            add_import::add_import,
+            replace_qualified_name_with_use::replace_qualified_name_with_use,
            add_missing_impl_members::add_missing_impl_members,
            add_missing_impl_members::add_missing_default_members,
            inline_local_variable::inline_local_variable,
@@ -184,7 +162,7 @@ mod helpers {
    use ra_syntax::TextRange;
    use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
-    use crate::{Assist, AssistCtx, AssistHandler};
+    use crate::{AssistCtx, AssistHandler};
    pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
        let (mut db, file_id) = RootDatabase::with_single_file(text);
@@ -202,10 +180,7 @@ mod helpers {
            FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
        let assist =
            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
+        let action = assist.0[0].action.clone().unwrap();
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
        let actual = action.edit.apply(&before);
        let actual_cursor_pos = match action.cursor_position {
@@ -225,10 +200,7 @@ mod helpers {
        let frange = FileRange { file_id, range };
        let assist =
            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
+        let action = assist.0[0].action.clone().unwrap();
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
        let mut actual = action.edit.apply(&before);
        if let Some(pos) = action.cursor_position {
@@ -244,10 +216,7 @@ mod helpers {
            FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
        let assist =
            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
+        let action = assist.0[0].action.clone().unwrap();
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
        let range = action.target.expect("expected target on action");
        assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
@@ -259,10 +228,7 @@ mod helpers {
        let frange = FileRange { file_id, range };
        let assist =
            assist(AssistCtx::new(&db, frange, true)).expect("code action is not applicable");
-        let action = match assist {
+        let action = assist.0[0].action.clone().unwrap();
-            Assist::Unresolved { .. } => unreachable!(),
-            Assist::Resolved { assist } => assist.get_first_action(),
-        };
        let range = action.target.expect("expected target on action");
        assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index eaacf8c9e..4d9641728 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -10,9 +10,9 @@ use hir_def::{
    per_ns::PerNs,
    resolver::HasResolver,
    type_ref::{Mutability, TypeRef},
-    AdtId, ConstId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId, LocalEnumVariantId,
+    AdtId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId,
-    LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
+    LocalEnumVariantId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId,
-    TypeParamId, UnionId,
+    TraitId, TypeAliasId, TypeParamId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
@@ -21,7 +21,7 @@ use hir_expand::{
 };
 use hir_ty::{
    autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
-    Canonical, InEnvironment, TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
+    Canonical, InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
@@ -270,7 +270,13 @@ impl StructField {
    pub fn ty(&self, db: &impl HirDatabase) -> Type {
        let var_id = self.parent.into();
-        let ty = db.field_types(var_id)[self.id].clone();
+        let generic_def_id: GenericDefId = match self.parent {
+            VariantDef::Struct(it) => it.id.into(),
+            VariantDef::Union(it) => it.id.into(),
+            VariantDef::EnumVariant(it) => it.parent.id.into(),
+        };
+        let substs = Substs::type_params(db, generic_def_id);
+        let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
        Type::new(db, self.parent.module(db).id.krate.into(), var_id, ty)
    }
@@ -755,7 +761,7 @@ pub struct TypeParam {
 impl TypeParam {
    pub fn name(self, db: &impl HirDatabase) -> Name {
        let params = db.generic_params(self.id.parent);
-        params.types[self.id.local_id].name.clone()
+        params.types[self.id.local_id].name.clone().unwrap_or_else(Name::missing)
    }
    pub fn module(self, db: &impl HirDatabase) -> Module {
@@ -789,8 +795,9 @@ impl ImplBlock {
    pub fn target_ty(&self, db: &impl HirDatabase) -> Type {
        let impl_data = db.impl_data(self.id);
        let resolver = self.id.resolver(db);
+        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
        let environment = TraitEnvironment::lower(db, &resolver);
-        let ty = Ty::from_hir(db, &resolver, &impl_data.target_type);
+        let ty = Ty::from_hir(&ctx, &impl_data.target_type);
        Type {
            krate: self.id.lookup(db).container.module(db).krate,
            ty: InEnvironment { value: ty, environment },
@@ -851,9 +858,10 @@ impl Type {
    fn from_def(
        db: &impl HirDatabase,
        krate: CrateId,
-        def: impl HasResolver + Into<TyDefId>,
+        def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
    ) -> Type {
-        let ty = db.ty(def.into());
+        let substs = Substs::type_params(db, def);
+        let ty = db.ty(def.into()).subst(&substs);
        Type::new(db, krate, def, ty)
    }
@@ -950,7 +958,7 @@ impl Type {
            match a_ty.ctor {
                TypeCtor::Tuple { .. } => {
                    for ty in a_ty.parameters.iter() {
-                        let ty = ty.clone().subst(&a_ty.parameters);
+                        let ty = ty.clone();
                        res.push(self.derived(ty));
                    }
                }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 86e422779..e1c7b7a20 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -58,7 +58,6 @@ pub use hir_def::{
    type_ref::Mutability,
 };
 pub use hir_expand::{
-    name::{name, Name},
+    name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, Origin,
-    HirFileId, InFile, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, Origin,
 };
 pub use hir_ty::{display::HirDisplay, CallableDef};
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 4f8fc9602..bb9a35c5d 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -178,6 +178,10 @@ impl SourceAnalyzer {
        }
    }
+    fn trait_env(&self, db: &impl HirDatabase) -> Arc<TraitEnvironment> {
+        TraitEnvironment::lower(db, &self.resolver)
+    }
    pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {
        let expr_id = if let Some(expr) = self.expand_expr(db, InFile::new(self.file_id, expr)) {
            self.body_source_map.as_ref()?.node_expr(expr.as_ref())?
@@ -186,14 +190,14 @@ impl SourceAnalyzer {
        };
        let ty = self.infer.as_ref()?[expr_id].clone();
-        let environment = TraitEnvironment::lower(db, &self.resolver);
+        let environment = self.trait_env(db);
        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
    }
    pub fn type_of_pat(&self, db: &impl HirDatabase, pat: &ast::Pat) -> Option<Type> {
        let pat_id = self.pat_id(pat)?;
        let ty = self.infer.as_ref()?[pat_id].clone();
-        let environment = TraitEnvironment::lower(db, &self.resolver);
+        let environment = self.trait_env(db);
        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
    }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 5c779521b..1fc892362 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -164,9 +164,9 @@ where
                            let match_expr = self.collect_expr_opt(condition.expr());
                            let placeholder_pat = self.missing_pat();
                            let arms = vec![
-                                MatchArm { pats: vec![pat], expr: then_branch, guard: None },
+                                MatchArm { pat, expr: then_branch, guard: None },
                                MatchArm {
-                                    pats: vec![placeholder_pat],
+                                    pat: placeholder_pat,
                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
                                    guard: None,
                                },
@@ -203,8 +203,8 @@ where
                            let placeholder_pat = self.missing_pat();
                            let break_ = self.alloc_expr_desugared(Expr::Break { expr: None });
                            let arms = vec![
-                                MatchArm { pats: vec![pat], expr: body, guard: None },
+                                MatchArm { pat, expr: body, guard: None },
-                                MatchArm { pats: vec![placeholder_pat], expr: break_, guard: None },
+                                MatchArm { pat: placeholder_pat, expr: break_, guard: None },
                            ];
                            let match_expr =
                                self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
@@ -250,7 +250,7 @@ where
                    match_arm_list
                        .arms()
                        .map(|arm| MatchArm {
-                            pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
+                            pat: self.collect_pat_opt(arm.pat()),
                            expr: self.collect_expr_opt(arm.expr()),
                            guard: arm
                                .guard()
@@ -587,6 +587,11 @@ where
                let path = p.path().and_then(|path| self.expander.parse_path(path));
                path.map(Pat::Path).unwrap_or(Pat::Missing)
            }
+            ast::Pat::OrPat(p) => {
+                let pats = p.pats().map(|p| self.collect_pat(p)).collect();
+                Pat::Or(pats)
+            }
+            ast::Pat::ParenPat(p) => return self.collect_pat_opt(p.pat()),
            ast::Pat::TuplePat(p) => {
                let args = p.args().map(|p| self.collect_pat(p)).collect();
                Pat::Tuple(args)
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index a63552327..a58a7b21f 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -158,9 +158,7 @@ fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope
            compute_expr_scopes(*expr, body, scopes, scope);
            for arm in arms {
                let scope = scopes.new_scope(scope);
-                for pat in &arm.pats {
+                scopes.add_bindings(body, scope, arm.pat);
-                    scopes.add_bindings(body, scope, *pat);
-                }
                scopes.set_scope(arm.expr, scope);
                compute_expr_scopes(arm.expr, body, scopes, scope);
            }
@@ -194,7 +192,7 @@ mod tests {
        let (off, code) = extract_offset(code);
        let code = {
            let mut buf = String::new();
-            let off = u32::from(off) as usize;
+            let off = off.to_usize();
            buf.push_str(&code[..off]);
            buf.push_str("marker");
            buf.push_str(&code[off..]);
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index 035824403..9707c5527 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -202,7 +202,7 @@ pub enum Array {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MatchArm {
-    pub pats: Vec<PatId>,
+    pub pat: PatId,
    pub guard: Option<ExprId>,
    pub expr: ExprId,
 }
@@ -382,6 +382,7 @@ pub enum Pat {
    Missing,
    Wild,
    Tuple(Vec<PatId>),
+    Or(Vec<PatId>),
    Record {
        path: Option<Path>,
        args: Vec<RecordFieldPat>,
@@ -420,7 +421,7 @@ impl Pat {
            Pat::Bind { subpat, .. } => {
                subpat.iter().copied().for_each(f);
            }
-            Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
+            Pat::Or(args) | Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
                args.iter().copied().for_each(f);
            }
            Pat::Ref { pat, .. } => f(*pat),
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index e9c28c730..f765e6edc 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -27,8 +27,16 @@ use crate::{
 /// Data about a generic parameter (to a function, struct, impl, ...).
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TypeParamData {
-    pub name: Name,
+    pub name: Option<Name>,
    pub default: Option<TypeRef>,
+    pub provenance: TypeParamProvenance,
+}
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum TypeParamProvenance {
+    TypeParamList,
+    TraitSelf,
+    ArgumentImplTrait,
 }
 /// Data about the generic parameters of a function, struct, impl, etc.
@@ -45,10 +53,17 @@ pub struct GenericParams {
 /// associated type bindings like `Iterator<Item = u32>`.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct WherePredicate {
-    pub type_ref: TypeRef,
+    pub target: WherePredicateTarget,
    pub bound: TypeBound,
 }
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum WherePredicateTarget {
+    TypeRef(TypeRef),
+    /// For desugared where predicates that can directly refer to a type param.
+    TypeParam(LocalTypeParamId),
+}
 type SourceMap = ArenaMap<LocalTypeParamId, Either<ast::TraitDef, ast::TypeParam>>;
 impl GenericParams {
@@ -68,6 +83,11 @@ impl GenericParams {
            GenericDefId::FunctionId(it) => {
                let src = it.lookup(db).source(db);
                generics.fill(&mut sm, &src.value);
+                // lower `impl Trait` in arguments
+                let data = db.function_data(it);
+                for param in &data.params {
+                    generics.fill_implicit_impl_trait_args(param);
+                }
                src.file_id
            }
            GenericDefId::AdtId(AdtId::StructId(it)) => {
@@ -89,8 +109,11 @@ impl GenericParams {
                let src = it.lookup(db).source(db);
                // traits get the Self type as an implicit first type parameter
-                let self_param_id =
+                let self_param_id = generics.types.alloc(TypeParamData {
-                    generics.types.alloc(TypeParamData { name: name![Self], default: None });
+                    name: Some(name![Self]),
+                    default: None,
+                    provenance: TypeParamProvenance::TraitSelf,
+                });
                sm.insert(self_param_id, Either::Left(src.value.clone()));
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
@@ -142,7 +165,11 @@ impl GenericParams {
            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
            // FIXME: Use `Path::from_src`
            let default = type_param.default_type().map(TypeRef::from_ast);
-            let param = TypeParamData { name: name.clone(), default };
+            let param = TypeParamData {
+                name: Some(name.clone()),
+                default,
+                provenance: TypeParamProvenance::TypeParamList,
+            };
            let param_id = self.types.alloc(param);
            sm.insert(param_id, Either::Right(type_param.clone()));
@@ -170,11 +197,43 @@ impl GenericParams {
            return;
        }
        let bound = TypeBound::from_ast(bound);
-        self.where_predicates.push(WherePredicate { type_ref, bound });
+        self.where_predicates
+            .push(WherePredicate { target: WherePredicateTarget::TypeRef(type_ref), bound });
+    }
+    fn fill_implicit_impl_trait_args(&mut self, type_ref: &TypeRef) {
+        type_ref.walk(&mut |type_ref| {
+            if let TypeRef::ImplTrait(bounds) = type_ref {
+                let param = TypeParamData {
+                    name: None,
+                    default: None,
+                    provenance: TypeParamProvenance::ArgumentImplTrait,
+                };
+                let param_id = self.types.alloc(param);
+                for bound in bounds {
+                    self.where_predicates.push(WherePredicate {
+                        target: WherePredicateTarget::TypeParam(param_id),
+                        bound: bound.clone(),
+                    });
+                }
+            }
+        });
    }
    pub fn find_by_name(&self, name: &Name) -> Option<LocalTypeParamId> {
-        self.types.iter().find_map(|(id, p)| if &p.name == name { Some(id) } else { None })
+        self.types
+            .iter()
+            .find_map(|(id, p)| if p.name.as_ref() == Some(name) { Some(id) } else { None })
+    }
+    pub fn find_trait_self_param(&self) -> Option<LocalTypeParamId> {
+        self.types.iter().find_map(|(id, p)| {
+            if p.provenance == TypeParamProvenance::TraitSelf {
+                Some(id)
+            } else {
+                None
+            }
+        })
    }
 }
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index f7bac5801..05cf4646a 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -490,10 +490,12 @@ impl Scope {
            }
            Scope::GenericParams { params, def } => {
                for (local_id, param) in params.types.iter() {
-                    f(
+                    if let Some(name) = &param.name {
-                        param.name.clone(),
+                        f(
-                        ScopeDef::GenericParam(TypeParamId { local_id, parent: *def }),
+                            name.clone(),
-                    )
+                            ScopeDef::GenericParam(TypeParamId { local_id, parent: *def }),
+                        )
+                    }
                }
            }
            Scope::ImplBlockScope(i) => {
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index 5f10e9a88..102fdb13d 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -124,6 +124,48 @@ impl TypeRef {
    pub(crate) fn unit() -> TypeRef {
        TypeRef::Tuple(Vec::new())
    }
+    pub fn walk(&self, f: &mut impl FnMut(&TypeRef)) {
+        go(self, f);
+        fn go(type_ref: &TypeRef, f: &mut impl FnMut(&TypeRef)) {
+            f(type_ref);
+            match type_ref {
+                TypeRef::Fn(types) | TypeRef::Tuple(types) => types.iter().for_each(|t| go(t, f)),
+                TypeRef::RawPtr(type_ref, _)
+                | TypeRef::Reference(type_ref, _)
+                | TypeRef::Array(type_ref)
+                | TypeRef::Slice(type_ref) => go(&type_ref, f),
+                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
+                    for bound in bounds {
+                        match bound {
+                            TypeBound::Path(path) => go_path(path, f),
+                            TypeBound::Error => (),
+                        }
+                    }
+                }
+                TypeRef::Path(path) => go_path(path, f),
+                TypeRef::Never | TypeRef::Placeholder | TypeRef::Error => {}
+            };
+        }
+        fn go_path(path: &Path, f: &mut impl FnMut(&TypeRef)) {
+            if let Some(type_ref) = path.type_anchor() {
+                go(type_ref, f);
+            }
+            for segment in path.segments().iter() {
+                if let Some(args_and_bindings) = segment.args_and_bindings {
+                    for arg in &args_and_bindings.args {
+                        let crate::path::GenericArg::Type(type_ref) = arg;
+                        go(type_ref, f);
+                    }
+                    for (_, type_ref) in &args_and_bindings.bindings {
+                        go(type_ref, f);
+                    }
+                }
+            }
+        }
+    }
 }
 pub(crate) fn type_bounds_from_ast(type_bounds_opt: Option<ast::TypeBoundList>) -> Vec<TypeBound> {
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 133805bdb..b2e10f445 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -187,13 +187,6 @@ pub mod known {
        PartialOrd,
        Eq,
        PartialEq,
-        // FIXME delete those after `ImportResolver` is removed.
-        hash,
-        fmt,
-        io,
-        Display,
-        Iterator,
-        Hasher,
    );
    // self/Self cannot be used as an identifier
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index eb521c7a0..e9bfcfa17 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -3,17 +3,18 @@
 use std::sync::Arc;
 use hir_def::{
-    db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, VariantId,
+    db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, TypeParamId,
+    VariantId,
 };
 use ra_arena::map::ArenaMap;
-use ra_db::{salsa, CrateId};
+use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
 use crate::{
    method_resolution::CrateImplBlocks,
    traits::{chalk, AssocTyValue, Impl},
-    CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, TraitRef, Ty, TyDefId, TypeCtor,
+    Binders, CallableDef, GenericPredicate, InferenceResult, PolyFnSig, Substs, TraitRef, Ty,
-    ValueTyDefId,
+    TyDefId, TypeCtor, ValueTyDefId,
 };
 #[salsa::query_group(HirDatabaseStorage)]
@@ -27,34 +28,33 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::lower::ty_query)]
    #[salsa::cycle(crate::lower::ty_recover)]
-    fn ty(&self, def: TyDefId) -> Ty;
+    fn ty(&self, def: TyDefId) -> Binders<Ty>;
    #[salsa::invoke(crate::lower::value_ty_query)]
-    fn value_ty(&self, def: ValueTyDefId) -> Ty;
+    fn value_ty(&self, def: ValueTyDefId) -> Binders<Ty>;
    #[salsa::invoke(crate::lower::impl_self_ty_query)]
    #[salsa::cycle(crate::lower::impl_self_ty_recover)]
-    fn impl_self_ty(&self, def: ImplId) -> Ty;
+    fn impl_self_ty(&self, def: ImplId) -> Binders<Ty>;
    #[salsa::invoke(crate::lower::impl_trait_query)]
-    fn impl_trait(&self, def: ImplId) -> Option<TraitRef>;
+    fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
    #[salsa::invoke(crate::lower::field_types_query)]
-    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Ty>>;
+    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>>;
    #[salsa::invoke(crate::callable_item_sig)]
-    fn callable_item_signature(&self, def: CallableDef) -> FnSig;
+    fn callable_item_signature(&self, def: CallableDef) -> PolyFnSig;
    #[salsa::invoke(crate::lower::generic_predicates_for_param_query)]
    #[salsa::cycle(crate::lower::generic_predicates_for_param_recover)]
    fn generic_predicates_for_param(
        &self,
-        def: GenericDefId,
+        param_id: TypeParamId,
-        param_idx: u32,
+    ) -> Arc<[Binders<GenericPredicate>]>;
-    ) -> Arc<[GenericPredicate]>;
    #[salsa::invoke(crate::lower::generic_predicates_query)]
-    fn generic_predicates(&self, def: GenericDefId) -> Arc<[GenericPredicate]>;
+    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>;
    #[salsa::invoke(crate::lower::generic_defaults_query)]
    fn generic_defaults(&self, def: GenericDefId) -> Substs;
@@ -77,6 +77,8 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::interned]
    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> crate::TypeCtorId;
    #[salsa::interned]
+    fn intern_type_param_id(&self, param_id: TypeParamId) -> GlobalTypeParamId;
+    #[salsa::interned]
    fn intern_chalk_impl(&self, impl_: Impl) -> crate::traits::GlobalImplId;
    #[salsa::interned]
    fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> crate::traits::AssocTyValueId;
@@ -117,3 +119,7 @@ fn infer(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
 fn hir_database_is_object_safe() {
    fn _assert_object_safe(_: &dyn HirDatabase) {}
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GlobalTypeParamId(salsa::InternId);
+impl_intern_key!(GlobalTypeParamId);
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index e2eda3134..a9d958c8b 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -34,7 +34,6 @@ use hir_expand::{diagnostics::DiagnosticSink, name::name};
 use ra_arena::map::ArenaMap;
 use ra_prof::profile;
 use ra_syntax::SmolStr;
-use test_utils::tested_by;
 use super::{
    primitive::{FloatTy, IntTy},
@@ -42,7 +41,9 @@ use super::{
    ApplicationTy, GenericPredicate, InEnvironment, ProjectionTy, Substs, TraitEnvironment,
    TraitRef, Ty, TypeCtor, TypeWalk, Uncertain,
 };
-use crate::{db::HirDatabase, infer::diagnostics::InferenceDiagnostic};
+use crate::{
+    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
+};
 pub(crate) use unify::unify;
@@ -271,38 +272,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        self.result.diagnostics.push(diagnostic);
    }
-    fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
+    fn make_ty_with_mode(
-        let ty = Ty::from_hir(
+        &mut self,
-            self.db,
+        type_ref: &TypeRef,
-            // FIXME use right resolver for block
+        impl_trait_mode: ImplTraitLoweringMode,
-            &self.resolver,
+    ) -> Ty {
-            type_ref,
+        // FIXME use right resolver for block
-        );
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
+            .with_impl_trait_mode(impl_trait_mode);
+        let ty = Ty::from_hir(&ctx, type_ref);
        let ty = self.insert_type_vars(ty);
        self.normalize_associated_types_in(ty)
    }
-    /// Replaces `impl Trait` in `ty` by type variables and obligations for
+    fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
-    /// those variables. This is done for function arguments when calling a
+        self.make_ty_with_mode(type_ref, ImplTraitLoweringMode::Disallowed)
-    /// function, and for return types when inside the function body, i.e. in
-    /// the cases where the `impl Trait` is 'transparent'. In other cases, `impl
-    /// Trait` is represented by `Ty::Opaque`.
-    fn insert_vars_for_impl_trait(&mut self, ty: Ty) -> Ty {
-        ty.fold(&mut |ty| match ty {
-            Ty::Opaque(preds) => {
-                tested_by!(insert_vars_for_impl_trait);
-                let var = self.table.new_type_var();
-                let var_subst = Substs::builder(1).push(var.clone()).build();
-                self.obligations.extend(
-                    preds
-                        .iter()
-                        .map(|pred| pred.clone().subst_bound_vars(&var_subst))
-                        .filter_map(Obligation::from_predicate),
-                );
-                var
-            }
-            _ => ty,
-        })
    }
    /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
@@ -446,19 +430,20 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            None => return (Ty::Unknown, None),
        };
        let resolver = &self.resolver;
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
        // FIXME: this should resolve assoc items as well, see this example:
        // https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521
        match resolver.resolve_path_in_type_ns_fully(self.db, path.mod_path()) {
            Some(TypeNs::AdtId(AdtId::StructId(strukt))) => {
-                let substs = Ty::substs_from_path(self.db, resolver, path, strukt.into());
+                let substs = Ty::substs_from_path(&ctx, path, strukt.into());
                let ty = self.db.ty(strukt.into());
-                let ty = self.insert_type_vars(ty.apply_substs(substs));
+                let ty = self.insert_type_vars(ty.subst(&substs));
                (ty, Some(strukt.into()))
            }
            Some(TypeNs::EnumVariantId(var)) => {
-                let substs = Ty::substs_from_path(self.db, resolver, path, var.into());
+                let substs = Ty::substs_from_path(&ctx, path, var.into());
                let ty = self.db.ty(var.parent.into());
-                let ty = self.insert_type_vars(ty.apply_substs(substs));
+                let ty = self.insert_type_vars(ty.subst(&substs));
                (ty, Some(var.into()))
            }
            Some(_) | None => (Ty::Unknown, None),
@@ -471,13 +456,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn collect_fn(&mut self, data: &FunctionData) {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
-        for (type_ref, pat) in data.params.iter().zip(body.params.iter()) {
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver)
-            let ty = self.make_ty(type_ref);
+            .with_impl_trait_mode(ImplTraitLoweringMode::Param);
+        let param_tys =
+            data.params.iter().map(|type_ref| Ty::from_hir(&ctx, type_ref)).collect::<Vec<_>>();
+        for (ty, pat) in param_tys.into_iter().zip(body.params.iter()) {
+            let ty = self.insert_type_vars(ty);
+            let ty = self.normalize_associated_types_in(ty);
            self.infer_pat(*pat, &ty, BindingMode::default());
        }
-        let return_ty = self.make_ty(&data.ret_type);
+        let return_ty = self.make_ty_with_mode(&data.ret_type, ImplTraitLoweringMode::Disallowed); // FIXME implement RPIT
-        self.return_ty = self.insert_vars_for_impl_trait(return_ty);
+        self.return_ty = return_ty;
    }
    fn infer_body(&mut self) {
diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 83c0c2c3f..f68a1439f 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -57,8 +57,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let trait_ref = db.impl_trait(impl_id)?;
                // `CoerseUnsized` has one generic parameter for the target type.
-                let cur_from_ty = trait_ref.substs.0.get(0)?;
+                let cur_from_ty = trait_ref.value.substs.0.get(0)?;
-                let cur_to_ty = trait_ref.substs.0.get(1)?;
+                let cur_to_ty = trait_ref.value.substs.0.get(1)?;
                match (&cur_from_ty, cur_to_ty) {
                    (ty_app!(ctor1, st1), ty_app!(ctor2, st2)) => {
@@ -66,9 +66,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                        // This works for smart-pointer-like coercion, which covers all impls from std.
                        st1.iter().zip(st2.iter()).enumerate().find_map(|(i, (ty1, ty2))| {
                            match (ty1, ty2) {
-                                (Ty::Param { idx: p1, .. }, Ty::Param { idx: p2, .. })
+                                (Ty::Bound(idx1), Ty::Bound(idx2)) if idx1 != idx2 => {
-                                    if p1 != p2 =>
-                                {
                                    Some(((*ctor1, *ctor2), i))
                                }
                                _ => None,
@@ -256,8 +254,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let unsize_generic_index = {
                    let mut index = None;
                    let mut multiple_param = false;
-                    field_tys[last_field_id].walk(&mut |ty| match ty {
+                    field_tys[last_field_id].value.walk(&mut |ty| match ty {
-                        &Ty::Param { idx, .. } => {
+                        &Ty::Bound(idx) => {
                            if index.is_none() {
                                index = Some(idx);
                            } else if Some(idx) != index {
@@ -276,10 +274,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                // Check other fields do not involve it.
                let mut multiple_used = false;
                fields.for_each(|(field_id, _data)| {
-                    field_tys[field_id].walk(&mut |ty| match ty {
+                    field_tys[field_id].value.walk(&mut |ty| match ty {
-                        &Ty::Param { idx, .. } if idx == unsize_generic_index => {
+                        &Ty::Bound(idx) if idx == unsize_generic_index => multiple_used = true,
-                            multiple_used = true
-                        }
                        _ => {}
                    })
                });
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 31259a01d..39d8bc0ca 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -10,7 +10,7 @@ use hir_def::{
    resolver::resolver_for_expr,
    AdtId, AssocContainerId, Lookup, StructFieldId,
 };
-use hir_expand::name::{name, Name};
+use hir_expand::name::Name;
 use ra_syntax::ast::RangeOp;
 use crate::{
@@ -19,8 +19,8 @@ use crate::{
    method_resolution, op,
    traits::InEnvironment,
    utils::{generics, variant_data, Generics},
-    ApplicationTy, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef, Ty,
+    ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef,
-    TypeCtor, TypeWalk, Uncertain,
+    Ty, TypeCtor, Uncertain,
 };
 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
@@ -165,12 +165,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            Expr::Match { expr, arms } => {
                let input_ty = self.infer_expr(*expr, &Expectation::none());
-                let mut result_ty = self.table.new_maybe_never_type_var();
+                let mut result_ty = if arms.len() == 0 {
+                    Ty::simple(TypeCtor::Never)
+                } else {
+                    self.table.new_type_var()
+                };
                for arm in arms {
-                    for &pat in &arm.pats {
+                    let _pat_ty = self.infer_pat(arm.pat, &input_ty, BindingMode::default());
-                        let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
-                    }
                    if let Some(guard_expr) = arm.guard {
                        self.infer_expr(
                            guard_expr,
@@ -236,8 +238,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                        self.result.record_field_resolutions.insert(field.expr, field_def);
                    }
                    let field_ty = field_def
-                        .map_or(Ty::Unknown, |it| field_types[it.local_id].clone())
+                        .map_or(Ty::Unknown, |it| field_types[it.local_id].clone().subst(&substs));
-                        .subst(&substs);
                    self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
                }
                if let Some(expr) = spread {
@@ -588,10 +589,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                self.write_method_resolution(tgt_expr, func);
                (ty, self.db.value_ty(func.into()), Some(generics(self.db, func.into())))
            }
-            None => (receiver_ty, Ty::Unknown, None),
+            None => (receiver_ty, Binders::new(0, Ty::Unknown), None),
        };
        let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
-        let method_ty = method_ty.apply_substs(substs);
+        let method_ty = method_ty.subst(&substs);
        let method_ty = self.insert_type_vars(method_ty);
        self.register_obligations_for_call(&method_ty);
        let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
@@ -635,7 +636,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    continue;
                }
-                let param_ty = self.insert_vars_for_impl_trait(param_ty);
                let param_ty = self.normalize_associated_types_in(param_ty);
                self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
            }
@@ -648,13 +648,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        generic_args: Option<&GenericArgs>,
        receiver_ty: &Ty,
    ) -> Substs {
-        let (total_len, _parent_len, child_len) =
+        let (parent_params, self_params, type_params, impl_trait_params) =
-            def_generics.as_ref().map_or((0, 0, 0), |g| g.len_split());
+            def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split());
+        assert_eq!(self_params, 0); // method shouldn't have another Self param
+        let total_len = parent_params + type_params + impl_trait_params;
        let mut substs = Vec::with_capacity(total_len);
        // Parent arguments are unknown, except for the receiver type
        if let Some(parent_generics) = def_generics.as_ref().map(|p| p.iter_parent()) {
            for (_id, param) in parent_generics {
-                if param.name == name![Self] {
+                if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf {
                    substs.push(receiver_ty.clone());
                } else {
                    substs.push(Ty::Unknown);
@@ -664,7 +666,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        // handle provided type arguments
        if let Some(generic_args) = generic_args {
            // if args are provided, it should be all of them, but we can't rely on that
-            for arg in generic_args.args.iter().take(child_len) {
+            for arg in generic_args.args.iter().take(type_params) {
                match arg {
                    GenericArg::Type(type_ref) => {
                        let ty = self.make_ty(type_ref);
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index a14662884..a5dfdf6c4 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -12,7 +12,7 @@ use hir_expand::name::Name;
 use test_utils::tested_by;
 use super::{BindingMode, InferenceContext};
-use crate::{db::HirDatabase, utils::variant_data, Substs, Ty, TypeCtor, TypeWalk};
+use crate::{db::HirDatabase, utils::variant_data, Substs, Ty, TypeCtor};
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn infer_tuple_struct_pat(
@@ -34,8 +34,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            let expected_ty = var_data
                .as_ref()
                .and_then(|d| d.field(&Name::new_tuple_field(i)))
-                .map_or(Ty::Unknown, |field| field_tys[field].clone())
+                .map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs));
-                .subst(&substs);
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat, &expected_ty, default_bm);
        }
@@ -65,7 +64,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        for subpat in subpats {
            let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
            let expected_ty =
-                matching_field.map_or(Ty::Unknown, |field| field_tys[field].clone()).subst(&substs);
+                matching_field.map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs));
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat.pat, &expected_ty, default_bm);
        }
@@ -83,6 +82,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let is_non_ref_pat = match &body[pat] {
            Pat::Tuple(..)
+            | Pat::Or(..)
            | Pat::TupleStruct { .. }
            | Pat::Record { .. }
            | Pat::Range { .. }
@@ -127,6 +127,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                Ty::apply(TypeCtor::Tuple { cardinality: args.len() as u16 }, Substs(inner_tys))
            }
+            Pat::Or(ref pats) => {
+                if let Some((first_pat, rest)) = pats.split_first() {
+                    let ty = self.infer_pat(*first_pat, expected, default_bm);
+                    for pat in rest {
+                        self.infer_pat(*pat, expected, default_bm);
+                    }
+                    ty
+                } else {
+                    Ty::Unknown
+                }
+            }
            Pat::Ref { pat, mutability } => {
                let expectation = match expected.as_reference() {
                    Some((inner_ty, exp_mut)) => {
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 2c1d4831d..686ce7a21 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -9,9 +9,9 @@ use hir_def::{
 };
 use hir_expand::name::Name;
-use crate::{db::HirDatabase, method_resolution, Substs, Ty, TypeWalk, ValueTyDefId};
+use crate::{db::HirDatabase, method_resolution, Substs, Ty, ValueTyDefId};
-use super::{ExprOrPatId, InferenceContext, TraitEnvironment, TraitRef};
+use super::{ExprOrPatId, InferenceContext, TraitRef};
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    pub(super) fn infer_path(
@@ -39,7 +39,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            }
            let ty = self.make_ty(type_ref);
            let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);
-            let ty = Ty::from_type_relative_path(self.db, resolver, ty, remaining_segments_for_ty);
+            let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver);
+            let ty = Ty::from_type_relative_path(&ctx, ty, remaining_segments_for_ty);
            self.resolve_ty_assoc_item(
                ty,
                &path.segments().last().expect("path had at least one segment").name,
@@ -69,12 +70,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            ValueNs::EnumVariantId(it) => it.into(),
        };
-        let mut ty = self.db.value_ty(typable);
+        let ty = self.db.value_ty(typable);
-        if let Some(self_subst) = self_subst {
+        // self_subst is just for the parent
-            ty = ty.subst(&self_subst);
+        let parent_substs = self_subst.unwrap_or_else(Substs::empty);
-        }
+        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
-        let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
+        let substs = Ty::substs_from_path(&ctx, path, typable);
-        let ty = ty.subst(&substs);
+        let full_substs = Substs::builder(substs.len())
+            .use_parent_substs(&parent_substs)
+            .fill(substs.0[parent_substs.len()..].iter().cloned())
+            .build();
+        let ty = ty.subst(&full_substs);
        Some(ty)
    }
@@ -98,13 +103,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            (TypeNs::TraitId(trait_), true) => {
                let segment =
                    remaining_segments.last().expect("there should be at least one segment here");
-                let trait_ref = TraitRef::from_resolved_path(
+                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
-                    self.db,
+                let trait_ref =
-                    &self.resolver,
+                    TraitRef::from_resolved_path(&ctx, trait_.into(), resolved_segment, None);
-                    trait_.into(),
-                    resolved_segment,
-                    None,
-                );
                self.resolve_trait_assoc_item(trait_ref, segment, id)
            }
            (def, _) => {
@@ -114,9 +115,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                // as Iterator>::Item::default`)
                let remaining_segments_for_ty =
                    remaining_segments.take(remaining_segments.len() - 1);
+                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
                let ty = Ty::from_partly_resolved_hir_path(
-                    self.db,
+                    &ctx,
-                    &self.resolver,
                    def,
                    resolved_segment,
                    remaining_segments_for_ty,
@@ -173,13 +174,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            AssocItemId::ConstId(c) => ValueNs::ConstId(c),
            AssocItemId::TypeAliasId(_) => unreachable!(),
        };
-        let substs = Substs::build_for_def(self.db, item)
-            .use_parent_substs(&trait_ref.substs)
-            .fill_with_params()
-            .build();
        self.write_assoc_resolution(id, item);
-        Some((def, Some(substs)))
+        Some((def, Some(trait_ref.substs)))
    }
    fn resolve_ty_assoc_item(
@@ -193,14 +190,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        }
        let canonical_ty = self.canonicalizer().canonicalize_ty(ty.clone());
-        let env = TraitEnvironment::lower(self.db, &self.resolver);
        let krate = self.resolver.krate()?;
        let traits_in_scope = self.resolver.traits_in_scope(self.db);
        method_resolution::iterate_method_candidates(
            &canonical_ty.value,
            self.db,
-            env,
+            self.trait_env.clone(),
            krate,
            &traits_in_scope,
            Some(name),
@@ -219,12 +215,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            .fill(iter::repeat_with(|| self.table.new_type_var()))
                            .build();
                        let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs);
-                        let substs = Substs::build_for_def(self.db, item)
-                            .use_parent_substs(&impl_substs)
-                            .fill_with_params()
-                            .build();
                        self.unify(&impl_self_ty, &ty);
-                        Some(substs)
+                        Some(impl_substs)
                    }
                    AssocContainerId::TraitId(trait_) => {
                        // we're picking this method
@@ -232,15 +224,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            .push(ty.clone())
                            .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                            .build();
-                        let substs = Substs::build_for_def(self.db, item)
-                            .use_parent_substs(&trait_substs)
-                            .fill_with_params()
-                            .build();
                        self.obligations.push(super::Obligation::Trait(TraitRef {
                            trait_,
-                            substs: trait_substs,
+                            substs: trait_substs.clone(),
                        }));
-                        Some(substs)
+                        Some(trait_substs)
                    }
                    AssocContainerId::ContainerId(_) => None,
                };
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 08d501ccd..c5fe18c85 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -44,8 +44,8 @@ use std::sync::Arc;
 use std::{fmt, iter, mem};
 use hir_def::{
-    expr::ExprId, type_ref::Mutability, AdtId, AssocContainerId, DefWithBodyId, GenericDefId,
+    expr::ExprId, generics::TypeParamProvenance, type_ref::Mutability, AdtId, AssocContainerId,
-    HasModule, Lookup, TraitId, TypeAliasId,
+    DefWithBodyId, GenericDefId, HasModule, Lookup, TraitId, TypeAliasId, TypeParamId,
 };
 use hir_expand::name::Name;
 use ra_db::{impl_intern_key, salsa, CrateId};
@@ -60,7 +60,9 @@ use display::{HirDisplay, HirFormatter};
 pub use autoderef::autoderef;
 pub use infer::{do_infer_query, InferTy, InferenceResult};
 pub use lower::CallableDef;
-pub use lower::{callable_item_sig, TyDefId, ValueTyDefId};
+pub use lower::{
+    callable_item_sig, ImplTraitLoweringMode, TyDefId, TyLoweringContext, ValueTyDefId,
+};
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 /// A type constructor or type name: this might be something like the primitive
@@ -285,22 +287,20 @@ pub enum Ty {
    /// trait and all its parameters are fully known.
    Projection(ProjectionTy),
-    /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
+    /// A placeholder for a type parameter; for example, `T` in `fn f<T>(x: T)
-    Param {
+    /// {}` when we're type-checking the body of that function. In this
-        /// The index of the parameter (starting with parameters from the
+    /// situation, we know this stands for *some* type, but don't know the exact
-        /// surrounding impl, then the current function).
+    /// type.
-        idx: u32,
+    Param(TypeParamId),
-        /// The name of the parameter, for displaying.
-        // FIXME get rid of this
+    /// A bound type variable. This is used in various places: when representing
-        name: Name,
+    /// some polymorphic type like the type of function `fn f<T>`, the type
-    },
+    /// parameters get turned into variables; during trait resolution, inference
+    /// variables get turned into bound variables and back; and in `Dyn` the
-    /// A bound type variable. Used during trait resolution to represent Chalk
+    /// `Self` type is represented with a bound variable as well.
-    /// variables, and in `Dyn` and `Opaque` bounds to represent the `Self` type.
    Bound(u32),
-    /// A type variable used during type checking. Not to be confused with a
+    /// A type variable used during type checking.
-    /// type parameter.
    Infer(InferTy),
    /// A trait object (`dyn Trait` or bare `Trait` in pre-2018 Rust).
@@ -364,15 +364,19 @@ impl Substs {
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
-    pub(crate) fn identity(generic_params: &Generics) -> Substs {
+    pub(crate) fn type_params_for_generics(generic_params: &Generics) -> Substs {
-        Substs(
+        Substs(generic_params.iter().map(|(id, _)| Ty::Param(id)).collect())
-            generic_params.iter().map(|(idx, p)| Ty::Param { idx, name: p.name.clone() }).collect(),
+    }
-        )
+    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
+    pub fn type_params(db: &impl HirDatabase, def: impl Into<GenericDefId>) -> Substs {
+        let params = generics(db, def.into());
+        Substs::type_params_for_generics(&params)
    }
    /// Return Substs that replace each parameter by a bound variable.
    pub(crate) fn bound_vars(generic_params: &Generics) -> Substs {
-        Substs(generic_params.iter().map(|(idx, _p)| Ty::Bound(idx)).collect())
+        Substs(generic_params.iter().enumerate().map(|(idx, _)| Ty::Bound(idx as u32)).collect())
    }
    pub fn build_for_def(db: &impl HirDatabase, def: impl Into<GenericDefId>) -> SubstsBuilder {
@@ -420,11 +424,6 @@ impl SubstsBuilder {
        self.fill((starting_from..).map(Ty::Bound))
    }
-    pub fn fill_with_params(self) -> Self {
-        let start = self.vec.len() as u32;
-        self.fill((start..).map(|idx| Ty::Param { idx, name: Name::missing() }))
-    }
    pub fn fill_with_unknown(self) -> Self {
        self.fill(iter::repeat(Ty::Unknown))
    }
@@ -451,6 +450,32 @@ impl Deref for Substs {
    }
 }
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Binders<T> {
+    pub num_binders: usize,
+    pub value: T,
+}
+impl<T> Binders<T> {
+    pub fn new(num_binders: usize, value: T) -> Self {
+        Self { num_binders, value }
+    }
+}
+impl<T: TypeWalk> Binders<T> {
+    /// Substitutes all variables.
+    pub fn subst(self, subst: &Substs) -> T {
+        assert_eq!(subst.len(), self.num_binders);
+        self.value.subst_bound_vars(subst)
+    }
+    /// Substitutes just a prefix of the variables (shifting the rest).
+    pub fn subst_prefix(self, subst: &Substs) -> Binders<T> {
+        assert!(subst.len() < self.num_binders);
+        Binders::new(self.num_binders - subst.len(), self.value.subst_bound_vars(subst))
+    }
+}
 /// A trait with type parameters. This includes the `Self`, so this represents a concrete type implementing the trait.
 /// Name to be bikeshedded: TraitBound? TraitImplements?
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -551,6 +576,9 @@ pub struct FnSig {
    params_and_return: Arc<[Ty]>,
 }
+/// A polymorphic function signature.
+pub type PolyFnSig = Binders<FnSig>;
 impl FnSig {
    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty) -> FnSig {
        params.push(ret);
@@ -730,22 +758,7 @@ pub trait TypeWalk {
        self
    }
-    /// Replaces type parameters in this type using the given `Substs`. (So e.g.
+    /// Substitutes `Ty::Bound` vars with the given substitution.
-    /// if `self` is `&[T]`, where type parameter T has index 0, and the
-    /// `Substs` contain `u32` at index 0, we'll have `&[u32]` afterwards.)
-    fn subst(self, substs: &Substs) -> Self
-    where
-        Self: Sized,
-    {
-        self.fold(&mut |ty| match ty {
-            Ty::Param { idx, name } => {
-                substs.get(idx as usize).cloned().unwrap_or(Ty::Param { idx, name })
-            }
-            ty => ty,
-        })
-    }
-    /// Substitutes `Ty::Bound` vars (as opposed to type parameters).
    fn subst_bound_vars(mut self, substs: &Substs) -> Self
    where
        Self: Sized,
@@ -755,6 +768,9 @@ pub trait TypeWalk {
                &mut Ty::Bound(idx) => {
                    if idx as usize >= binders && (idx as usize - binders) < substs.len() {
                        *ty = substs.0[idx as usize - binders].clone();
+                    } else if idx as usize >= binders + substs.len() {
+                        // shift free binders
+                        *ty = Ty::Bound(idx - substs.len() as u32);
                    }
                }
                _ => {}
@@ -880,7 +896,7 @@ impl HirDisplay for ApplicationTy {
                write!(f, ") -> {}", sig.ret().display(f.db))?;
            }
            TypeCtor::FnDef(def) => {
-                let sig = f.db.callable_item_signature(def);
+                let sig = f.db.callable_item_signature(def).subst(&self.parameters);
                let name = match def {
                    CallableDef::FunctionId(ff) => f.db.function_data(ff).name.clone(),
                    CallableDef::StructId(s) => f.db.struct_data(s).name.clone(),
@@ -896,9 +912,16 @@ impl HirDisplay for ApplicationTy {
                    }
                }
                if self.parameters.len() > 0 {
-                    write!(f, "<")?;
+                    let generics = generics(f.db, def.into());
-                    f.write_joined(&*self.parameters.0, ", ")?;
+                    let (parent_params, self_param, type_params, _impl_trait_params) =
-                    write!(f, ">")?;
+                        generics.provenance_split();
+                    let total_len = parent_params + self_param + type_params;
+                    // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
+                    if total_len > 0 {
+                        write!(f, "<")?;
+                        f.write_joined(&self.parameters.0[..total_len], ", ")?;
+                        write!(f, ">")?;
+                    }
                }
                write!(f, "(")?;
                f.write_joined(sig.params(), ", ")?;
@@ -1009,7 +1032,24 @@ impl HirDisplay for Ty {
        match self {
            Ty::Apply(a_ty) => a_ty.hir_fmt(f)?,
            Ty::Projection(p_ty) => p_ty.hir_fmt(f)?,
-            Ty::Param { name, .. } => write!(f, "{}", name)?,
+            Ty::Param(id) => {
+                let generics = generics(f.db, id.parent);
+                let param_data = &generics.params.types[id.local_id];
+                match param_data.provenance {
+                    TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {
+                        write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
+                    }
+                    TypeParamProvenance::ArgumentImplTrait => {
+                        write!(f, "impl ")?;
+                        let bounds = f.db.generic_predicates_for_param(*id);
+                        let substs = Substs::type_params_for_generics(&generics);
+                        write_bounds_like_dyn_trait(
+                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
+                            f,
+                        )?;
+                    }
+                }
+            }
            Ty::Bound(idx) => write!(f, "?{}", idx)?,
            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
                match self {
@@ -1017,66 +1057,7 @@ impl HirDisplay for Ty {
                    Ty::Opaque(_) => write!(f, "impl ")?,
                    _ => unreachable!(),
                };
-                // Note: This code is written to produce nice results (i.e.
+                write_bounds_like_dyn_trait(&predicates, f)?;
-                // corresponding to surface Rust) for types that can occur in
-                // actual Rust. It will have weird results if the predicates
-                // aren't as expected (i.e. self types = $0, projection
-                // predicates for a certain trait come after the Implemented
-                // predicate for that trait).
-                let mut first = true;
-                let mut angle_open = false;
-                for p in predicates.iter() {
-                    match p {
-                        GenericPredicate::Implemented(trait_ref) => {
-                            if angle_open {
-                                write!(f, ">")?;
-                            }
-                            if !first {
-                                write!(f, " + ")?;
-                            }
-                            // We assume that the self type is $0 (i.e. the
-                            // existential) here, which is the only thing that's
-                            // possible in actual Rust, and hence don't print it
-                            write!(f, "{}", f.db.trait_data(trait_ref.trait_).name.clone())?;
-                            if trait_ref.substs.len() > 1 {
-                                write!(f, "<")?;
-                                f.write_joined(&trait_ref.substs[1..], ", ")?;
-                                // there might be assoc type bindings, so we leave the angle brackets open
-                                angle_open = true;
-                            }
-                        }
-                        GenericPredicate::Projection(projection_pred) => {
-                            // in types in actual Rust, these will always come
-                            // after the corresponding Implemented predicate
-                            if angle_open {
-                                write!(f, ", ")?;
-                            } else {
-                                write!(f, "<")?;
-                                angle_open = true;
-                            }
-                            let name =
-                                f.db.type_alias_data(projection_pred.projection_ty.associated_ty)
-                                    .name
-                                    .clone();
-                            write!(f, "{} = ", name)?;
-                            projection_pred.ty.hir_fmt(f)?;
-                        }
-                        GenericPredicate::Error => {
-                            if angle_open {
-                                // impl Trait<X, {error}>
-                                write!(f, ", ")?;
-                            } else if !first {
-                                // impl Trait + {error}
-                                write!(f, " + ")?;
-                            }
-                            p.hir_fmt(f)?;
-                        }
-                    }
-                    first = false;
-                }
-                if angle_open {
-                    write!(f, ">")?;
-                }
            }
            Ty::Unknown => write!(f, "{{unknown}}")?,
            Ty::Infer(..) => write!(f, "_")?,
@@ -1085,6 +1066,71 @@ impl HirDisplay for Ty {
    }
 }
+fn write_bounds_like_dyn_trait(
+    predicates: &[GenericPredicate],
+    f: &mut HirFormatter<impl HirDatabase>,
+) -> fmt::Result {
+    // Note: This code is written to produce nice results (i.e.
+    // corresponding to surface Rust) for types that can occur in
+    // actual Rust. It will have weird results if the predicates
+    // aren't as expected (i.e. self types = $0, projection
+    // predicates for a certain trait come after the Implemented
+    // predicate for that trait).
+    let mut first = true;
+    let mut angle_open = false;
+    for p in predicates.iter() {
+        match p {
+            GenericPredicate::Implemented(trait_ref) => {
+                if angle_open {
+                    write!(f, ">")?;
+                }
+                if !first {
+                    write!(f, " + ")?;
+                }
+                // We assume that the self type is $0 (i.e. the
+                // existential) here, which is the only thing that's
+                // possible in actual Rust, and hence don't print it
+                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name.clone())?;
+                if trait_ref.substs.len() > 1 {
+                    write!(f, "<")?;
+                    f.write_joined(&trait_ref.substs[1..], ", ")?;
+                    // there might be assoc type bindings, so we leave the angle brackets open
+                    angle_open = true;
+                }
+            }
+            GenericPredicate::Projection(projection_pred) => {
+                // in types in actual Rust, these will always come
+                // after the corresponding Implemented predicate
+                if angle_open {
+                    write!(f, ", ")?;
+                } else {
+                    write!(f, "<")?;
+                    angle_open = true;
+                }
+                let name =
+                    f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name.clone();
+                write!(f, "{} = ", name)?;
+                projection_pred.ty.hir_fmt(f)?;
+            }
+            GenericPredicate::Error => {
+                if angle_open {
+                    // impl Trait<X, {error}>
+                    write!(f, ", ")?;
+                } else if !first {
+                    // impl Trait + {error}
+                    write!(f, " + ")?;
+                }
+                p.hir_fmt(f)?;
+            }
+        }
+        first = false;
+    }
+    if angle_open {
+        write!(f, ">")?;
+    }
+    Ok(())
+}
 impl TraitRef {
    fn hir_fmt_ext(&self, f: &mut HirFormatter<impl HirDatabase>, use_as: bool) -> fmt::Result {
        if f.should_truncate() {
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 2c2ecee9c..c68c5852b 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -10,12 +10,13 @@ use std::sync::Arc;
 use hir_def::{
    builtin_type::BuiltinType,
-    generics::WherePredicate,
+    generics::{TypeParamProvenance, WherePredicate, WherePredicateTarget},
    path::{GenericArg, Path, PathSegment, PathSegments},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{TypeBound, TypeRef},
    AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule, ImplId,
-    LocalStructFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
+    LocalStructFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    VariantId,
 };
 use ra_arena::map::ArenaMap;
 use ra_db::CrateId;
@@ -27,63 +28,158 @@ use crate::{
        all_super_traits, associated_type_by_name_including_super_traits, generics, make_mut_slice,
        variant_data,
    },
-    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef,
+    Binders, FnSig, GenericPredicate, PolyFnSig, ProjectionPredicate, ProjectionTy, Substs,
-    Ty, TypeCtor, TypeWalk,
+    TraitEnvironment, TraitRef, Ty, TypeCtor,
 };
+#[derive(Debug)]
+pub struct TyLoweringContext<'a, DB: HirDatabase> {
+    pub db: &'a DB,
+    pub resolver: &'a Resolver,
+    /// Note: Conceptually, it's thinkable that we could be in a location where
+    /// some type params should be represented as placeholders, and others
+    /// should be converted to variables. I think in practice, this isn't
+    /// possible currently, so this should be fine for now.
+    pub type_param_mode: TypeParamLoweringMode,
+    pub impl_trait_mode: ImplTraitLoweringMode,
+    pub impl_trait_counter: std::cell::Cell<u16>,
+}
+impl<'a, DB: HirDatabase> TyLoweringContext<'a, DB> {
+    pub fn new(db: &'a DB, resolver: &'a Resolver) -> Self {
+        let impl_trait_counter = std::cell::Cell::new(0);
+        let impl_trait_mode = ImplTraitLoweringMode::Disallowed;
+        let type_param_mode = TypeParamLoweringMode::Placeholder;
+        Self { db, resolver, impl_trait_mode, impl_trait_counter, type_param_mode }
+    }
+    pub fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self {
+        Self { impl_trait_mode, ..self }
+    }
+    pub fn with_type_param_mode(self, type_param_mode: TypeParamLoweringMode) -> Self {
+        Self { type_param_mode, ..self }
+    }
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ImplTraitLoweringMode {
+    /// `impl Trait` gets lowered into an opaque type that doesn't unify with
+    /// anything except itself. This is used in places where values flow 'out',
+    /// i.e. for arguments of the function we're currently checking, and return
+    /// types of functions we're calling.
+    Opaque,
+    /// `impl Trait` gets lowered into a type variable. Used for argument
+    /// position impl Trait when inside the respective function, since it allows
+    /// us to support that without Chalk.
+    Param,
+    /// `impl Trait` gets lowered into a variable that can unify with some
+    /// type. This is used in places where values flow 'in', i.e. for arguments
+    /// of functions we're calling, and the return type of the function we're
+    /// currently checking.
+    Variable,
+    /// `impl Trait` is disallowed and will be an error.
+    Disallowed,
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum TypeParamLoweringMode {
+    Placeholder,
+    Variable,
+}
 impl Ty {
-    pub fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self {
+    pub fn from_hir(ctx: &TyLoweringContext<'_, impl HirDatabase>, type_ref: &TypeRef) -> Self {
        match type_ref {
            TypeRef::Never => Ty::simple(TypeCtor::Never),
            TypeRef::Tuple(inner) => {
-                let inner_tys: Arc<[Ty]> =
+                let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| Ty::from_hir(ctx, tr)).collect();
-                    inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect();
                Ty::apply(
                    TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
                    Substs(inner_tys),
                )
            }
-            TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
+            TypeRef::Path(path) => Ty::from_hir_path(ctx, path),
            TypeRef::RawPtr(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty)
            }
            TypeRef::Array(inner) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                Ty::apply_one(TypeCtor::Array, inner_ty)
            }
            TypeRef::Slice(inner) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                Ty::apply_one(TypeCtor::Slice, inner_ty)
            }
            TypeRef::Reference(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, resolver, inner);
+                let inner_ty = Ty::from_hir(ctx, inner);
                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
            }
            TypeRef::Placeholder => Ty::Unknown,
            TypeRef::Fn(params) => {
-                let sig = Substs(params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect());
+                let sig = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
                Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
            }
            TypeRef::DynTrait(bounds) => {
                let self_ty = Ty::Bound(0);
                let predicates = bounds
                    .iter()
-                    .flat_map(|b| {
+                    .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone()))
-                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
-                    })
                    .collect();
                Ty::Dyn(predicates)
            }
            TypeRef::ImplTrait(bounds) => {
-                let self_ty = Ty::Bound(0);
+                match ctx.impl_trait_mode {
-                let predicates = bounds
+                    ImplTraitLoweringMode::Opaque => {
-                    .iter()
+                        let self_ty = Ty::Bound(0);
-                    .flat_map(|b| {
+                        let predicates = bounds
-                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
+                            .iter()
-                    })
+                            .flat_map(|b| {
-                    .collect();
+                                GenericPredicate::from_type_bound(ctx, b, self_ty.clone())
-                Ty::Opaque(predicates)
+                            })
+                            .collect();
+                        Ty::Opaque(predicates)
+                    }
+                    ImplTraitLoweringMode::Param => {
+                        let idx = ctx.impl_trait_counter.get();
+                        ctx.impl_trait_counter.set(idx + 1);
+                        if let Some(def) = ctx.resolver.generic_def() {
+                            let generics = generics(ctx.db, def);
+                            let param = generics
+                                .iter()
+                                .filter(|(_, data)| {
+                                    data.provenance == TypeParamProvenance::ArgumentImplTrait
+                                })
+                                .nth(idx as usize)
+                                .map_or(Ty::Unknown, |(id, _)| Ty::Param(id));
+                            param
+                        } else {
+                            Ty::Unknown
+                        }
+                    }
+                    ImplTraitLoweringMode::Variable => {
+                        let idx = ctx.impl_trait_counter.get();
+                        ctx.impl_trait_counter.set(idx + 1);
+                        let (parent_params, self_params, list_params, _impl_trait_params) =
+                            if let Some(def) = ctx.resolver.generic_def() {
+                                let generics = generics(ctx.db, def);
+                                generics.provenance_split()
+                            } else {
+                                (0, 0, 0, 0)
+                            };
+                        Ty::Bound(
+                            idx as u32
+                                + parent_params as u32
+                                + self_params as u32
+                                + list_params as u32,
+                        )
+                    }
+                    ImplTraitLoweringMode::Disallowed => {
+                        // FIXME: report error
+                        Ty::Unknown
+                    }
+                }
            }
            TypeRef::Error => Ty::Unknown,
        }
@@ -93,10 +189,9 @@ impl Ty {
    /// lower the self types of the predicates since that could lead to cycles.
    /// So we just check here if the `type_ref` resolves to a generic param, and which.
    fn from_hir_only_param(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        type_ref: &TypeRef,
-    ) -> Option<u32> {
+    ) -> Option<TypeParamId> {
        let path = match type_ref {
            TypeRef::Path(path) => path,
            _ => return None,
@@ -107,29 +202,26 @@ impl Ty {
        if path.segments().len() > 1 {
            return None;
        }
-        let resolution = match resolver.resolve_path_in_type_ns(db, path.mod_path()) {
+        let resolution = match ctx.resolver.resolve_path_in_type_ns(ctx.db, path.mod_path()) {
            Some((it, None)) => it,
            _ => return None,
        };
        if let TypeNs::GenericParam(param_id) = resolution {
-            let generics = generics(db, resolver.generic_def().expect("generics in scope"));
+            Some(param_id)
-            let idx = generics.param_idx(param_id);
-            Some(idx)
        } else {
            None
        }
    }
    pub(crate) fn from_type_relative_path(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        ty: Ty,
        remaining_segments: PathSegments<'_>,
    ) -> Ty {
        if remaining_segments.len() == 1 {
            // resolve unselected assoc types
            let segment = remaining_segments.first().unwrap();
-            Ty::select_associated_type(db, resolver, ty, segment)
+            Ty::select_associated_type(ctx, ty, segment)
        } else if remaining_segments.len() > 1 {
            // FIXME report error (ambiguous associated type)
            Ty::Unknown
@@ -139,20 +231,18 @@ impl Ty {
    }
    pub(crate) fn from_partly_resolved_hir_path(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        resolution: TypeNs,
        resolved_segment: PathSegment<'_>,
        remaining_segments: PathSegments<'_>,
    ) -> Ty {
        let ty = match resolution {
            TypeNs::TraitId(trait_) => {
-                let trait_ref =
+                let trait_ref = TraitRef::from_resolved_path(ctx, trait_, resolved_segment, None);
-                    TraitRef::from_resolved_path(db, resolver, trait_, resolved_segment, None);
                return if remaining_segments.len() == 1 {
                    let segment = remaining_segments.first().unwrap();
                    let associated_ty = associated_type_by_name_including_super_traits(
-                        db,
+                        ctx.db,
                        trait_ref.trait_,
                        &segment.name,
                    );
@@ -177,37 +267,55 @@ impl Ty {
                };
            }
            TypeNs::GenericParam(param_id) => {
-                let generics = generics(db, resolver.generic_def().expect("generics in scope"));
+                let generics =
-                let idx = generics.param_idx(param_id);
+                    generics(ctx.db, ctx.resolver.generic_def().expect("generics in scope"));
-                // FIXME: maybe return name in resolution?
+                match ctx.type_param_mode {
-                let name = generics.param_name(param_id);
+                    TypeParamLoweringMode::Placeholder => Ty::Param(param_id),
-                Ty::Param { idx, name }
+                    TypeParamLoweringMode::Variable => {
+                        let idx = generics.param_idx(param_id).expect("matching generics");
+                        Ty::Bound(idx)
+                    }
+                }
            }
-            TypeNs::SelfType(impl_id) => db.impl_self_ty(impl_id).clone(),
+            TypeNs::SelfType(impl_id) => {
-            TypeNs::AdtSelfType(adt) => db.ty(adt.into()),
+                let generics = generics(ctx.db, impl_id.into());
+                let substs = match ctx.type_param_mode {
-            TypeNs::AdtId(it) => Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()),
+                    TypeParamLoweringMode::Placeholder => {
-            TypeNs::BuiltinType(it) => {
+                        Substs::type_params_for_generics(&generics)
-                Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into())
+                    }
+                    TypeParamLoweringMode::Variable => Substs::bound_vars(&generics),
+                };
+                ctx.db.impl_self_ty(impl_id).subst(&substs)
            }
-            TypeNs::TypeAliasId(it) => {
+            TypeNs::AdtSelfType(adt) => {
-                Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into())
+                let generics = generics(ctx.db, adt.into());
+                let substs = match ctx.type_param_mode {
+                    TypeParamLoweringMode::Placeholder => {
+                        Substs::type_params_for_generics(&generics)
+                    }
+                    TypeParamLoweringMode::Variable => Substs::bound_vars(&generics),
+                };
+                ctx.db.ty(adt.into()).subst(&substs)
            }
+            TypeNs::AdtId(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
+            TypeNs::BuiltinType(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
+            TypeNs::TypeAliasId(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
            // FIXME: report error
            TypeNs::EnumVariantId(_) => return Ty::Unknown,
        };
-        Ty::from_type_relative_path(db, resolver, ty, remaining_segments)
+        Ty::from_type_relative_path(ctx, ty, remaining_segments)
    }
-    pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Ty {
+    pub(crate) fn from_hir_path(ctx: &TyLoweringContext<'_, impl HirDatabase>, path: &Path) -> Ty {
        // Resolve the path (in type namespace)
        if let Some(type_ref) = path.type_anchor() {
-            let ty = Ty::from_hir(db, resolver, &type_ref);
+            let ty = Ty::from_hir(ctx, &type_ref);
-            return Ty::from_type_relative_path(db, resolver, ty, path.segments());
+            return Ty::from_type_relative_path(ctx, ty, path.segments());
        }
        let (resolution, remaining_index) =
-            match resolver.resolve_path_in_type_ns(db, path.mod_path()) {
+            match ctx.resolver.resolve_path_in_type_ns(ctx.db, path.mod_path()) {
                Some(it) => it,
                None => return Ty::Unknown,
            };
@@ -218,39 +326,44 @@ impl Ty {
            ),
            Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)),
        };
-        Ty::from_partly_resolved_hir_path(
+        Ty::from_partly_resolved_hir_path(ctx, resolution, resolved_segment, remaining_segments)
-            db,
-            resolver,
-            resolution,
-            resolved_segment,
-            remaining_segments,
-        )
    }
    fn select_associated_type(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        self_ty: Ty,
        segment: PathSegment<'_>,
    ) -> Ty {
-        let param_idx = match self_ty {
+        let def = match ctx.resolver.generic_def() {
-            Ty::Param { idx, .. } => idx,
-            _ => return Ty::Unknown, // Error: Ambiguous associated type
-        };
-        let def = match resolver.generic_def() {
            Some(def) => def,
            None => return Ty::Unknown, // this can't actually happen
        };
-        let predicates = db.generic_predicates_for_param(def.into(), param_idx);
+        let param_id = match self_ty {
-        let traits_from_env = predicates.iter().filter_map(|pred| match pred {
+            Ty::Param(id) if ctx.type_param_mode == TypeParamLoweringMode::Placeholder => id,
-            GenericPredicate::Implemented(tr) if tr.self_ty() == &self_ty => Some(tr.trait_),
+            Ty::Bound(idx) if ctx.type_param_mode == TypeParamLoweringMode::Variable => {
+                let generics = generics(ctx.db, def);
+                let param_id = if let Some((id, _)) = generics.iter().nth(idx as usize) {
+                    id
+                } else {
+                    return Ty::Unknown;
+                };
+                param_id
+            }
+            _ => return Ty::Unknown, // Error: Ambiguous associated type
+        };
+        let predicates = ctx.db.generic_predicates_for_param(param_id);
+        let traits_from_env = predicates.iter().filter_map(|pred| match &pred.value {
+            GenericPredicate::Implemented(tr) => Some(tr.trait_),
            _ => None,
        });
-        let traits = traits_from_env.flat_map(|t| all_super_traits(db, t));
+        let traits = traits_from_env.flat_map(|t| all_super_traits(ctx.db, t));
        for t in traits {
-            if let Some(associated_ty) = db.trait_data(t).associated_type_by_name(&segment.name) {
+            if let Some(associated_ty) = ctx.db.trait_data(t).associated_type_by_name(&segment.name)
-                let substs =
+            {
-                    Substs::build_for_def(db, t).push(self_ty.clone()).fill_with_unknown().build();
+                let substs = Substs::build_for_def(ctx.db, t)
+                    .push(self_ty.clone())
+                    .fill_with_unknown()
+                    .build();
                // FIXME handle type parameters on the segment
                return Ty::Projection(ProjectionTy { associated_ty, parameters: substs });
            }
@@ -259,8 +372,7 @@ impl Ty {
    }
    fn from_hir_path_inner(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        segment: PathSegment<'_>,
        typable: TyDefId,
    ) -> Ty {
@@ -269,15 +381,14 @@ impl Ty {
            TyDefId::AdtId(it) => Some(it.into()),
            TyDefId::TypeAliasId(it) => Some(it.into()),
        };
-        let substs = substs_from_path_segment(db, resolver, segment, generic_def, false);
+        let substs = substs_from_path_segment(ctx, segment, generic_def, false);
-        db.ty(typable).subst(&substs)
+        ctx.db.ty(typable).subst(&substs)
    }
    /// Collect generic arguments from a path into a `Substs`. See also
    /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
    pub(super) fn substs_from_path(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        path: &Path,
        // Note that we don't call `db.value_type(resolved)` here,
        // `ValueTyDefId` is just a convenient way to pass generics and
@@ -305,52 +416,49 @@ impl Ty {
                (segment, Some(var.parent.into()))
            }
        };
-        substs_from_path_segment(db, resolver, segment, generic_def, false)
+        substs_from_path_segment(ctx, segment, generic_def, false)
    }
 }
 pub(super) fn substs_from_path_segment(
-    db: &impl HirDatabase,
+    ctx: &TyLoweringContext<'_, impl HirDatabase>,
-    resolver: &Resolver,
    segment: PathSegment<'_>,
    def_generic: Option<GenericDefId>,
-    add_self_param: bool,
+    _add_self_param: bool,
 ) -> Substs {
    let mut substs = Vec::new();
-    let def_generics = def_generic.map(|def| generics(db, def.into()));
+    let def_generics = def_generic.map(|def| generics(ctx.db, def.into()));
-    let (total_len, parent_len, child_len) = def_generics.map_or((0, 0, 0), |g| g.len_split());
+    let (parent_params, self_params, type_params, impl_trait_params) =
-    substs.extend(iter::repeat(Ty::Unknown).take(parent_len));
+        def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split());
-    if add_self_param {
+    substs.extend(iter::repeat(Ty::Unknown).take(parent_params));
-        // FIXME this add_self_param argument is kind of a hack: Traits have the
-        // Self type as an implicit first type parameter, but it can't be
-        // actually provided in the type arguments
-        // (well, actually sometimes it can, in the form of type-relative paths: `<Foo as Default>::default()`)
-        substs.push(Ty::Unknown);
-    }
    if let Some(generic_args) = &segment.args_and_bindings {
+        if !generic_args.has_self_type {
+            substs.extend(iter::repeat(Ty::Unknown).take(self_params));
+        }
+        let expected_num =
+            if generic_args.has_self_type { self_params + type_params } else { type_params };
+        let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 };
        // if args are provided, it should be all of them, but we can't rely on that
-        let self_param_correction = if add_self_param { 1 } else { 0 };
+        for arg in generic_args.args.iter().skip(skip).take(expected_num) {
-        let child_len = child_len - self_param_correction;
-        for arg in generic_args.args.iter().take(child_len) {
            match arg {
                GenericArg::Type(type_ref) => {
-                    let ty = Ty::from_hir(db, resolver, type_ref);
+                    let ty = Ty::from_hir(ctx, type_ref);
                    substs.push(ty);
                }
            }
        }
    }
+    let total_len = parent_params + self_params + type_params + impl_trait_params;
    // add placeholders for args that were not provided
-    let supplied_params = substs.len();
+    for _ in substs.len()..total_len {
-    for _ in supplied_params..total_len {
        substs.push(Ty::Unknown);
    }
    assert_eq!(substs.len(), total_len);
    // handle defaults
    if let Some(def_generic) = def_generic {
-        let default_substs = db.generic_defaults(def_generic.into());
+        let default_substs = ctx.db.generic_defaults(def_generic.into());
        assert_eq!(substs.len(), default_substs.len());
        for (i, default_ty) in default_substs.iter().enumerate() {
@@ -365,27 +473,25 @@ pub(super) fn substs_from_path_segment(
 impl TraitRef {
    fn from_path(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        path: &Path,
        explicit_self_ty: Option<Ty>,
    ) -> Option<Self> {
-        let resolved = match resolver.resolve_path_in_type_ns_fully(db, path.mod_path())? {
+        let resolved = match ctx.resolver.resolve_path_in_type_ns_fully(ctx.db, path.mod_path())? {
            TypeNs::TraitId(tr) => tr,
            _ => return None,
        };
        let segment = path.segments().last().expect("path should have at least one segment");
-        Some(TraitRef::from_resolved_path(db, resolver, resolved.into(), segment, explicit_self_ty))
+        Some(TraitRef::from_resolved_path(ctx, resolved.into(), segment, explicit_self_ty))
    }
    pub(crate) fn from_resolved_path(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        resolved: TraitId,
        segment: PathSegment<'_>,
        explicit_self_ty: Option<Ty>,
    ) -> Self {
-        let mut substs = TraitRef::substs_from_path(db, resolver, segment, resolved);
+        let mut substs = TraitRef::substs_from_path(ctx, segment, resolved);
        if let Some(self_ty) = explicit_self_ty {
            make_mut_slice(&mut substs.0)[0] = self_ty;
        }
@@ -393,8 +499,7 @@ impl TraitRef {
    }
    fn from_hir(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        type_ref: &TypeRef,
        explicit_self_ty: Option<Ty>,
    ) -> Option<Self> {
@@ -402,28 +507,26 @@ impl TraitRef {
            TypeRef::Path(path) => path,
            _ => return None,
        };
-        TraitRef::from_path(db, resolver, path, explicit_self_ty)
+        TraitRef::from_path(ctx, path, explicit_self_ty)
    }
    fn substs_from_path(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        segment: PathSegment<'_>,
        resolved: TraitId,
    ) -> Substs {
        let has_self_param =
            segment.args_and_bindings.as_ref().map(|a| a.has_self_type).unwrap_or(false);
-        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), !has_self_param)
+        substs_from_path_segment(ctx, segment, Some(resolved.into()), !has_self_param)
    }
    pub(crate) fn from_type_bound(
-        db: &impl HirDatabase,
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
-        resolver: &Resolver,
        bound: &TypeBound,
        self_ty: Ty,
    ) -> Option<TraitRef> {
        match bound {
-            TypeBound::Path(path) => TraitRef::from_path(db, resolver, path, Some(self_ty)),
+            TypeBound::Path(path) => TraitRef::from_path(ctx, path, Some(self_ty)),
            TypeBound::Error => None,
        }
    }
@@ -431,33 +534,44 @@ impl TraitRef {
 impl GenericPredicate {
    pub(crate) fn from_where_predicate<'a>(
-        db: &'a impl HirDatabase,
+        ctx: &'a TyLoweringContext<'a, impl HirDatabase>,
-        resolver: &'a Resolver,
        where_predicate: &'a WherePredicate,
    ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        let self_ty = Ty::from_hir(db, resolver, &where_predicate.type_ref);
+        let self_ty = match &where_predicate.target {
-        GenericPredicate::from_type_bound(db, resolver, &where_predicate.bound, self_ty)
+            WherePredicateTarget::TypeRef(type_ref) => Ty::from_hir(ctx, type_ref),
+            WherePredicateTarget::TypeParam(param_id) => {
+                let generic_def = ctx.resolver.generic_def().expect("generics in scope");
+                let generics = generics(ctx.db, generic_def);
+                let param_id = hir_def::TypeParamId { parent: generic_def, local_id: *param_id };
+                match ctx.type_param_mode {
+                    TypeParamLoweringMode::Placeholder => Ty::Param(param_id),
+                    TypeParamLoweringMode::Variable => {
+                        let idx = generics.param_idx(param_id).expect("matching generics");
+                        Ty::Bound(idx)
+                    }
+                }
+            }
+        };
+        GenericPredicate::from_type_bound(ctx, &where_predicate.bound, self_ty)
    }
    pub(crate) fn from_type_bound<'a>(
-        db: &'a impl HirDatabase,
+        ctx: &'a TyLoweringContext<'a, impl HirDatabase>,
-        resolver: &'a Resolver,
        bound: &'a TypeBound,
        self_ty: Ty,
    ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        let trait_ref = TraitRef::from_type_bound(db, &resolver, bound, self_ty);
+        let trait_ref = TraitRef::from_type_bound(ctx, bound, self_ty);
        iter::once(trait_ref.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented))
            .chain(
-                trait_ref.into_iter().flat_map(move |tr| {
+                trait_ref
-                    assoc_type_bindings_from_type_bound(db, resolver, bound, tr)
+                    .into_iter()
-                }),
+                    .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)),
            )
    }
 }
 fn assoc_type_bindings_from_type_bound<'a>(
-    db: &'a impl HirDatabase,
+    ctx: &'a TyLoweringContext<'a, impl HirDatabase>,
-    resolver: &'a Resolver,
    bound: &'a TypeBound,
    trait_ref: TraitRef,
 ) -> impl Iterator<Item = GenericPredicate> + 'a {
@@ -471,21 +585,21 @@ fn assoc_type_bindings_from_type_bound<'a>(
        .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
        .map(move |(name, type_ref)| {
            let associated_ty =
-                associated_type_by_name_including_super_traits(db, trait_ref.trait_, &name);
+                associated_type_by_name_including_super_traits(ctx.db, trait_ref.trait_, &name);
            let associated_ty = match associated_ty {
                None => return GenericPredicate::Error,
                Some(t) => t,
            };
            let projection_ty =
                ProjectionTy { associated_ty, parameters: trait_ref.substs.clone() };
-            let ty = Ty::from_hir(db, resolver, type_ref);
+            let ty = Ty::from_hir(ctx, type_ref);
            let projection_predicate = ProjectionPredicate { projection_ty, ty };
            GenericPredicate::Projection(projection_predicate)
        })
 }
 /// Build the signature of a callable item (function, struct or enum variant).
-pub fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
+pub fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> PolyFnSig {
    match def {
        CallableDef::FunctionId(f) => fn_sig_for_fn(db, f),
        CallableDef::StructId(s) => fn_sig_for_struct_constructor(db, s),
@@ -497,16 +611,19 @@ pub fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
 pub(crate) fn field_types_query(
    db: &impl HirDatabase,
    variant_id: VariantId,
-) -> Arc<ArenaMap<LocalStructFieldId, Ty>> {
+) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>> {
    let var_data = variant_data(db, variant_id);
-    let resolver = match variant_id {
+    let (resolver, def): (_, GenericDefId) = match variant_id {
-        VariantId::StructId(it) => it.resolver(db),
+        VariantId::StructId(it) => (it.resolver(db), it.into()),
-        VariantId::UnionId(it) => it.resolver(db),
+        VariantId::UnionId(it) => (it.resolver(db), it.into()),
-        VariantId::EnumVariantId(it) => it.parent.resolver(db),
+        VariantId::EnumVariantId(it) => (it.parent.resolver(db), it.parent.into()),
    };
+    let generics = generics(db, def);
    let mut res = ArenaMap::default();
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    for (field_id, field_data) in var_data.fields().iter() {
-        res.insert(field_id, Ty::from_hir(db, &resolver, &field_data.type_ref))
+        res.insert(field_id, Binders::new(generics.len(), Ty::from_hir(&ctx, &field_data.type_ref)))
    }
    Arc::new(res)
 }
@@ -521,32 +638,43 @@ pub(crate) fn field_types_query(
 /// these are fine: `T: Foo<U::Item>, U: Foo<()>`.
 pub(crate) fn generic_predicates_for_param_query(
    db: &impl HirDatabase,
-    def: GenericDefId,
+    param_id: TypeParamId,
-    param_idx: u32,
+) -> Arc<[Binders<GenericPredicate>]> {
-) -> Arc<[GenericPredicate]> {
+    let resolver = param_id.parent.resolver(db);
-    let resolver = def.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    let generics = generics(db, param_id.parent);
    resolver
        .where_predicates_in_scope()
        // we have to filter out all other predicates *first*, before attempting to lower them
-        .filter(|pred| Ty::from_hir_only_param(db, &resolver, &pred.type_ref) == Some(param_idx))
+        .filter(|pred| match &pred.target {
-        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+            WherePredicateTarget::TypeRef(type_ref) => {
+                Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id)
+            }
+            WherePredicateTarget::TypeParam(local_id) => *local_id == param_id.local_id,
+        })
+        .flat_map(|pred| {
+            GenericPredicate::from_where_predicate(&ctx, pred)
+                .map(|p| Binders::new(generics.len(), p))
+        })
        .collect()
 }
 pub(crate) fn generic_predicates_for_param_recover(
    _db: &impl HirDatabase,
    _cycle: &[String],
-    _def: &GenericDefId,
+    _param_id: &TypeParamId,
-    _param_idx: &u32,
+) -> Arc<[Binders<GenericPredicate>]> {
-) -> Arc<[GenericPredicate]> {
    Arc::new([])
 }
 impl TraitEnvironment {
    pub fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
+        let ctx = TyLoweringContext::new(db, &resolver)
+            .with_type_param_mode(TypeParamLoweringMode::Placeholder);
        let predicates = resolver
            .where_predicates_in_scope()
-            .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+            .flat_map(|pred| GenericPredicate::from_where_predicate(&ctx, pred))
            .collect::<Vec<_>>();
        Arc::new(TraitEnvironment { predicates })
@@ -557,57 +685,74 @@ impl TraitEnvironment {
 pub(crate) fn generic_predicates_query(
    db: &impl HirDatabase,
    def: GenericDefId,
-) -> Arc<[GenericPredicate]> {
+) -> Arc<[Binders<GenericPredicate>]> {
    let resolver = def.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    let generics = generics(db, def);
    resolver
        .where_predicates_in_scope()
-        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+        .flat_map(|pred| {
+            GenericPredicate::from_where_predicate(&ctx, pred)
+                .map(|p| Binders::new(generics.len(), p))
+        })
        .collect()
 }
 /// Resolve the default type params from generics
 pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDefId) -> Substs {
    let resolver = def.resolver(db);
+    let ctx = TyLoweringContext::new(db, &resolver);
    let generic_params = generics(db, def.into());
    let defaults = generic_params
        .iter()
-        .map(|(_idx, p)| p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(db, &resolver, t)))
+        .map(|(_idx, p)| p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t)))
        .collect();
    Substs(defaults)
 }
-fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> FnSig {
+fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> PolyFnSig {
    let data = db.function_data(def);
    let resolver = def.resolver(db);
-    let params = data.params.iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
+    let ctx_params = TyLoweringContext::new(db, &resolver)
-    let ret = Ty::from_hir(db, &resolver, &data.ret_type);
+        .with_impl_trait_mode(ImplTraitLoweringMode::Variable)
-    FnSig::from_params_and_return(params, ret)
+        .with_type_param_mode(TypeParamLoweringMode::Variable);
+    let params = data.params.iter().map(|tr| Ty::from_hir(&ctx_params, tr)).collect::<Vec<_>>();
+    let ctx_ret = ctx_params.with_impl_trait_mode(ImplTraitLoweringMode::Opaque);
+    let ret = Ty::from_hir(&ctx_ret, &data.ret_type);
+    let generics = generics(db, def.into());
+    let num_binders = generics.len();
+    Binders::new(num_binders, FnSig::from_params_and_return(params, ret))
 }
 /// Build the declared type of a function. This should not need to look at the
 /// function body.
-fn type_for_fn(db: &impl HirDatabase, def: FunctionId) -> Ty {
+fn type_for_fn(db: &impl HirDatabase, def: FunctionId) -> Binders<Ty> {
    let generics = generics(db, def.into());
-    let substs = Substs::identity(&generics);
+    let substs = Substs::bound_vars(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
 }
 /// Build the declared type of a const.
-fn type_for_const(db: &impl HirDatabase, def: ConstId) -> Ty {
+fn type_for_const(db: &impl HirDatabase, def: ConstId) -> Binders<Ty> {
    let data = db.const_data(def);
+    let generics = generics(db, def.into());
    let resolver = def.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    Ty::from_hir(db, &resolver, &data.type_ref)
+    Binders::new(generics.len(), Ty::from_hir(&ctx, &data.type_ref))
 }
 /// Build the declared type of a static.
-fn type_for_static(db: &impl HirDatabase, def: StaticId) -> Ty {
+fn type_for_static(db: &impl HirDatabase, def: StaticId) -> Binders<Ty> {
    let data = db.static_data(def);
    let resolver = def.resolver(db);
+    let ctx = TyLoweringContext::new(db, &resolver);
-    Ty::from_hir(db, &resolver, &data.type_ref)
+    Binders::new(0, Ty::from_hir(&ctx, &data.type_ref))
 }
 /// Build the declared type of a static.
@@ -621,68 +766,69 @@ fn type_for_builtin(def: BuiltinType) -> Ty {
    })
 }
-fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> FnSig {
+fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> PolyFnSig {
    let struct_data = db.struct_data(def.into());
    let fields = struct_data.variant_data.fields();
    let resolver = def.resolver(db);
-    let params = fields
+    let ctx =
-        .iter()
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
+    let params =
-        .collect::<Vec<_>>();
+        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.into());
-    FnSig::from_params_and_return(params, ret)
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
 }
 /// Build the type of a tuple struct constructor.
-fn type_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> Ty {
+fn type_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> Binders<Ty> {
    let struct_data = db.struct_data(def.into());
    if struct_data.variant_data.is_unit() {
        return type_for_adt(db, def.into()); // Unit struct
    }
    let generics = generics(db, def.into());
-    let substs = Substs::identity(&generics);
+    let substs = Substs::bound_vars(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
 }
-fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> FnSig {
+fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> PolyFnSig {
    let enum_data = db.enum_data(def.parent);
    let var_data = &enum_data.variants[def.local_id];
    let fields = var_data.variant_data.fields();
    let resolver = def.parent.resolver(db);
-    let params = fields
+    let ctx =
-        .iter()
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
+    let params =
-        .collect::<Vec<_>>();
+        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
-    let generics = generics(db, def.parent.into());
+    let ret = type_for_adt(db, def.parent.into());
-    let substs = Substs::identity(&generics);
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
-    let ret = type_for_adt(db, def.parent.into()).subst(&substs);
-    FnSig::from_params_and_return(params, ret)
 }
 /// Build the type of a tuple enum variant constructor.
-fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> Ty {
+fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> Binders<Ty> {
    let enum_data = db.enum_data(def.parent);
    let var_data = &enum_data.variants[def.local_id].variant_data;
    if var_data.is_unit() {
        return type_for_adt(db, def.parent.into()); // Unit variant
    }
    let generics = generics(db, def.parent.into());
-    let substs = Substs::identity(&generics);
+    let substs = Substs::bound_vars(&generics);
-    Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs)
+    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs))
 }
-fn type_for_adt(db: &impl HirDatabase, adt: AdtId) -> Ty {
+fn type_for_adt(db: &impl HirDatabase, adt: AdtId) -> Binders<Ty> {
    let generics = generics(db, adt.into());
-    Ty::apply(TypeCtor::Adt(adt), Substs::identity(&generics))
+    let substs = Substs::bound_vars(&generics);
+    Binders::new(substs.len(), Ty::apply(TypeCtor::Adt(adt), substs))
 }
-fn type_for_type_alias(db: &impl HirDatabase, t: TypeAliasId) -> Ty {
+fn type_for_type_alias(db: &impl HirDatabase, t: TypeAliasId) -> Binders<Ty> {
    let generics = generics(db, t.into());
    let resolver = t.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    let type_ref = &db.type_alias_data(t).type_ref;
-    let substs = Substs::identity(&generics);
+    let substs = Substs::bound_vars(&generics);
-    let inner = Ty::from_hir(db, &resolver, type_ref.as_ref().unwrap_or(&TypeRef::Error));
+    let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error));
-    inner.subst(&substs)
+    Binders::new(substs.len(), inner)
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -736,19 +882,24 @@ impl_froms!(ValueTyDefId: FunctionId, StructId, EnumVariantId, ConstId, StaticId
 /// `struct Foo(usize)`, we have two types: The type of the struct itself, and
 /// the constructor function `(usize) -> Foo` which lives in the values
 /// namespace.
-pub(crate) fn ty_query(db: &impl HirDatabase, def: TyDefId) -> Ty {
+pub(crate) fn ty_query(db: &impl HirDatabase, def: TyDefId) -> Binders<Ty> {
    match def {
-        TyDefId::BuiltinType(it) => type_for_builtin(it),
+        TyDefId::BuiltinType(it) => Binders::new(0, type_for_builtin(it)),
        TyDefId::AdtId(it) => type_for_adt(db, it),
        TyDefId::TypeAliasId(it) => type_for_type_alias(db, it),
    }
 }
-pub(crate) fn ty_recover(_db: &impl HirDatabase, _cycle: &[String], _def: &TyDefId) -> Ty {
+pub(crate) fn ty_recover(db: &impl HirDatabase, _cycle: &[String], def: &TyDefId) -> Binders<Ty> {
-    Ty::Unknown
+    let num_binders = match *def {
+        TyDefId::BuiltinType(_) => 0,
+        TyDefId::AdtId(it) => generics(db, it.into()).len(),
+        TyDefId::TypeAliasId(it) => generics(db, it.into()).len(),
+    };
+    Binders::new(num_binders, Ty::Unknown)
 }
-pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Ty {
+pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Binders<Ty> {
    match def {
        ValueTyDefId::FunctionId(it) => type_for_fn(db, it),
        ValueTyDefId::StructId(it) => type_for_struct_constructor(db, it),
@@ -758,24 +909,36 @@ pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Ty {
    }
 }
-pub(crate) fn impl_self_ty_query(db: &impl HirDatabase, impl_id: ImplId) -> Ty {
+pub(crate) fn impl_self_ty_query(db: &impl HirDatabase, impl_id: ImplId) -> Binders<Ty> {
    let impl_data = db.impl_data(impl_id);
    let resolver = impl_id.resolver(db);
-    Ty::from_hir(db, &resolver, &impl_data.target_type)
+    let generics = generics(db, impl_id.into());
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
+    Binders::new(generics.len(), Ty::from_hir(&ctx, &impl_data.target_type))
 }
 pub(crate) fn impl_self_ty_recover(
-    _db: &impl HirDatabase,
+    db: &impl HirDatabase,
    _cycle: &[String],
-    _impl_id: &ImplId,
+    impl_id: &ImplId,
-) -> Ty {
+) -> Binders<Ty> {
-    Ty::Unknown
+    let generics = generics(db, (*impl_id).into());
+    Binders::new(generics.len(), Ty::Unknown)
 }
-pub(crate) fn impl_trait_query(db: &impl HirDatabase, impl_id: ImplId) -> Option<TraitRef> {
+pub(crate) fn impl_trait_query(
+    db: &impl HirDatabase,
+    impl_id: ImplId,
+) -> Option<Binders<TraitRef>> {
    let impl_data = db.impl_data(impl_id);
    let resolver = impl_id.resolver(db);
+    let ctx =
+        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    let self_ty = db.impl_self_ty(impl_id);
    let target_trait = impl_data.target_trait.as_ref()?;
-    TraitRef::from_hir(db, &resolver, target_trait, Some(self_ty.clone()))
+    Some(Binders::new(
+        self_ty.num_binders,
+        TraitRef::from_hir(&ctx, target_trait, Some(self_ty.value.clone()))?,
+    ))
 }
diff --git a/crates/ra_hir_ty/src/marks.rs b/crates/ra_hir_ty/src/marks.rs
index fe74acf11..0f754eb9c 100644
--- a/crates/ra_hir_ty/src/marks.rs
+++ b/crates/ra_hir_ty/src/marks.rs
@@ -6,5 +6,4 @@ test_utils::marks!(
    type_var_resolves_to_int_var
    match_ergonomics_ref
    coerce_merge_fail_fallback
-    insert_vars_for_impl_trait
 );
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 5bacbbd7c..5283bff28 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -61,11 +61,11 @@ impl CrateImplBlocks {
            for impl_id in module_data.scope.impls() {
                match db.impl_trait(impl_id) {
                    Some(tr) => {
-                        res.impls_by_trait.entry(tr.trait_).or_default().push(impl_id);
+                        res.impls_by_trait.entry(tr.value.trait_).or_default().push(impl_id);
                    }
                    None => {
                        let self_ty = db.impl_self_ty(impl_id);
-                        if let Some(self_ty_fp) = TyFingerprint::for_impl(&self_ty) {
+                        if let Some(self_ty_fp) = TyFingerprint::for_impl(&self_ty.value) {
                            res.impls.entry(self_ty_fp).or_default().push(impl_id);
                        }
                    }
@@ -496,7 +496,7 @@ fn transform_receiver_ty(
        AssocContainerId::ContainerId(_) => unreachable!(),
    };
    let sig = db.callable_item_signature(function_id.into());
-    Some(sig.params()[0].clone().subst(&substs))
+    Some(sig.value.params()[0].clone().subst_bound_vars(&substs))
 }
 pub fn implements_trait(
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 76a1b46c0..fc5ef36a5 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -75,7 +75,7 @@ fn test2() {
    [124; 131) 'loop {}': !
    [129; 131) '{}': ()
    [160; 173) '{     gen() }': *mut [U]
-    [166; 169) 'gen': fn gen<U>() -> *mut [T; _]
+    [166; 169) 'gen': fn gen<U>() -> *mut [U; _]
    [166; 171) 'gen()': *mut [U; _]
    [186; 420) '{     ...rr); }': ()
    [196; 199) 'arr': &[u8; _]
@@ -85,14 +85,14 @@ fn test2() {
    [227; 228) 'a': &[u8]
    [237; 240) 'arr': &[u8; _]
    [250; 251) 'b': u8
-    [254; 255) 'f': fn f<u8>(&[T]) -> T
+    [254; 255) 'f': fn f<u8>(&[u8]) -> u8
    [254; 260) 'f(arr)': u8
    [256; 259) 'arr': &[u8; _]
    [270; 271) 'c': &[u8]
    [280; 287) '{ arr }': &[u8]
    [282; 285) 'arr': &[u8; _]
    [297; 298) 'd': u8
-    [301; 302) 'g': fn g<u8>(S<&[T]>) -> T
+    [301; 302) 'g': fn g<u8>(S<&[u8]>) -> u8
    [301; 316) 'g(S { a: arr })': u8
    [303; 315) 'S { a: arr }': S<&[u8]>
    [310; 313) 'arr': &[u8; _]
@@ -164,15 +164,15 @@ fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
    [400; 401) 'c': C<[u8; _]>
    [415; 481) '{     ...(c); }': ()
    [425; 426) 'd': A<[{unknown}]>
-    [429; 433) 'foo1': fn foo1<{unknown}>(A<[T]>) -> A<[T]>
+    [429; 433) 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
    [429; 436) 'foo1(a)': A<[{unknown}]>
    [434; 435) 'a': A<[u8; _]>
    [446; 447) 'e': B<[u8]>
-    [450; 454) 'foo2': fn foo2<u8>(B<[T]>) -> B<[T]>
+    [450; 454) 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
    [450; 457) 'foo2(b)': B<[u8]>
    [455; 456) 'b': B<[u8; _]>
    [467; 468) 'f': C<[u8]>
-    [471; 475) 'foo3': fn foo3<u8>(C<[T]>) -> C<[T]>
+    [471; 475) 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
    [471; 478) 'foo3(c)': C<[u8]>
    [476; 477) 'c': C<[u8; _]>
    "###
@@ -202,7 +202,7 @@ fn test() {
    [64; 123) 'if tru...     }': &[i32]
    [67; 71) 'true': bool
    [72; 97) '{     ...     }': &[i32]
-    [82; 85) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [82; 85) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [82; 91) 'foo(&[1])': &[i32]
    [86; 90) '&[1]': &[i32; _]
    [87; 90) '[1]': [i32; _]
@@ -242,7 +242,7 @@ fn test() {
    [83; 86) '[1]': [i32; _]
    [84; 85) '1': i32
    [98; 123) '{     ...     }': &[i32]
-    [108; 111) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [108; 111) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [108; 117) 'foo(&[1])': &[i32]
    [112; 116) '&[1]': &[i32; _]
    [113; 116) '[1]': [i32; _]
@@ -275,7 +275,7 @@ fn test(i: i32) {
    [70; 147) 'match ...     }': &[i32]
    [76; 77) 'i': i32
    [88; 89) '2': i32
-    [93; 96) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [93; 102) 'foo(&[2])': &[i32]
    [97; 101) '&[2]': &[i32; _]
    [98; 101) '[2]': [i32; _]
@@ -320,7 +320,7 @@ fn test(i: i32) {
    [94; 97) '[1]': [i32; _]
    [95; 96) '1': i32
    [107; 108) '2': i32
-    [112; 115) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [112; 121) 'foo(&[2])': &[i32]
    [116; 120) '&[2]': &[i32; _]
    [117; 120) '[2]': [i32; _]
@@ -438,16 +438,16 @@ fn test() {
    [43; 45) '*x': T
    [44; 45) 'x': &T
    [58; 127) '{     ...oo); }': ()
-    [64; 73) 'takes_ref': fn takes_ref<Foo>(&T) -> T
+    [64; 73) 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
    [64; 79) 'takes_ref(&Foo)': Foo
    [74; 78) '&Foo': &Foo
    [75; 78) 'Foo': Foo
-    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&T) -> T
+    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
    [85; 101) 'takes_...&&Foo)': &Foo
    [95; 100) '&&Foo': &&Foo
    [96; 100) '&Foo': &Foo
    [97; 100) 'Foo': Foo
-    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&T) -> T
+    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
    [107; 124) 'takes_...&&Foo)': &&Foo
    [117; 123) '&&&Foo': &&&Foo
    [118; 123) '&&Foo': &&Foo
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index ce9a06fde..1722563aa 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -27,7 +27,7 @@ fn test() {
    [66; 73) 'loop {}': !
    [71; 73) '{}': ()
    [133; 160) '{     ...o"); }': ()
-    [139; 149) '<[_]>::foo': fn foo<u8>(&[T]) -> T
+    [139; 149) '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
    [139; 157) '<[_]>:..."foo")': u8
    [150; 156) 'b"foo"': &[u8]
    "###
@@ -175,7 +175,7 @@ fn test() {
    [98; 101) 'val': T
    [123; 155) '{     ...32); }': ()
    [133; 134) 'a': Gen<u32>
-    [137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
+    [137; 146) 'Gen::make': fn make<u32>(u32) -> Gen<u32>
    [137; 152) 'Gen::make(0u32)': Gen<u32>
    [147; 151) '0u32': u32
    "###
@@ -206,7 +206,7 @@ fn test() {
    [95; 98) '{ }': ()
    [118; 146) '{     ...e(); }': ()
    [128; 129) 'a': Gen<u32>
-    [132; 141) 'Gen::make': fn make<u32>() -> Gen<T>
+    [132; 141) 'Gen::make': fn make<u32>() -> Gen<u32>
    [132; 143) 'Gen::make()': Gen<u32>
    "###
    );
@@ -260,7 +260,7 @@ fn test() {
    [91; 94) '{ }': ()
    [114; 149) '{     ...e(); }': ()
    [124; 125) 'a': Gen<u32>
-    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<T>
+    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<u32>
    [128; 146) 'Gen::<...make()': Gen<u32>
    "###
    );
@@ -291,7 +291,7 @@ fn test() {
    [117; 120) '{ }': ()
    [140; 180) '{     ...e(); }': ()
    [150; 151) 'a': Gen<u32, u64>
-    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, T>
+    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
    [154; 177) 'Gen::<...make()': Gen<u32, u64>
    "###
    );
@@ -475,7 +475,7 @@ fn test() {
        @r###"
    [33; 37) 'self': &Self
    [102; 127) '{     ...d(); }': ()
-    [108; 109) 'S': S<u32>(T) -> S<T>
+    [108; 109) 'S': S<u32>(u32) -> S<u32>
    [108; 115) 'S(1u32)': S<u32>
    [108; 124) 'S(1u32...thod()': u32
    [110; 114) '1u32': u32
@@ -501,13 +501,13 @@ fn test() {
        @r###"
    [87; 193) '{     ...t(); }': ()
    [97; 99) 's1': S
-    [105; 121) 'Defaul...efault': fn default<S>() -> Self
+    [105; 121) 'Defaul...efault': fn default<S>() -> S
    [105; 123) 'Defaul...ault()': S
    [133; 135) 's2': S
-    [138; 148) 'S::default': fn default<S>() -> Self
+    [138; 148) 'S::default': fn default<S>() -> S
    [138; 150) 'S::default()': S
    [160; 162) 's3': S
-    [165; 188) '<S as ...efault': fn default<S>() -> Self
+    [165; 188) '<S as ...efault': fn default<S>() -> S
    [165; 190) '<S as ...ault()': S
    "###
    );
@@ -533,13 +533,13 @@ fn test() {
        @r###"
    [127; 211) '{     ...e(); }': ()
    [137; 138) 'a': u32
-    [141; 148) 'S::make': fn make<S, u32>() -> T
+    [141; 148) 'S::make': fn make<S, u32>() -> u32
    [141; 150) 'S::make()': u32
    [160; 161) 'b': u64
-    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> T
+    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
    [164; 180) 'G::<u6...make()': u64
    [190; 191) 'c': f64
-    [199; 206) 'G::make': fn make<G<f64>, f64>() -> T
+    [199; 206) 'G::make': fn make<G<f64>, f64>() -> f64
    [199; 208) 'G::make()': f64
    "###
    );
@@ -567,19 +567,19 @@ fn test() {
        @r###"
    [135; 313) '{     ...e(); }': ()
    [145; 146) 'a': (u32, i64)
-    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (T, U)
+    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
    [149; 165) 'S::mak...i64>()': (u32, i64)
    [175; 176) 'b': (u32, i64)
-    [189; 196) 'S::make': fn make<S, u32, i64>() -> (T, U)
+    [189; 196) 'S::make': fn make<S, u32, i64>() -> (u32, i64)
    [189; 198) 'S::make()': (u32, i64)
    [208; 209) 'c': (u32, i64)
-    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
+    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
    [212; 235) 'G::<u3...i64>()': (u32, i64)
    [245; 246) 'd': (u32, i64)
-    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
+    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
    [259; 275) 'G::mak...i64>()': (u32, i64)
    [285; 286) 'e': (u32, i64)
-    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (T, U)
+    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
    [301; 310) 'G::make()': (u32, i64)
    "###
    );
@@ -601,7 +601,7 @@ fn test() {
        @r###"
    [101; 127) '{     ...e(); }': ()
    [111; 112) 'a': (S<i32>, i64)
-    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (Self, T)
+    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
    [115; 124) 'S::make()': (S<i32>, i64)
    "###
    );
@@ -625,10 +625,10 @@ fn test() {
        @r###"
    [131; 203) '{     ...e(); }': ()
    [141; 142) 'a': (S<u64>, i64)
-    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (Self, T)
+    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
    [158; 167) 'S::make()': (S<u64>, i64)
    [177; 178) 'b': (S<u32>, i32)
-    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (Self, T)
+    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
    [191; 200) 'S::make()': (S<u32>, i32)
    "###
    );
@@ -651,10 +651,10 @@ fn test() {
        @r###"
    [107; 211) '{     ...>(); }': ()
    [117; 118) 'a': (S<u64>, i64, u8)
-    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
+    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
    [121; 152) '<S as ...<u8>()': (S<u64>, i64, u8)
    [162; 163) 'b': (S<u64>, i64, u8)
-    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
+    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
    [182; 208) 'Trait:...<u8>()': (S<u64>, i64, u8)
    "###
    );
@@ -697,7 +697,7 @@ fn test<U, T: Trait<U>>(t: T) {
    [71; 72) 't': T
    [77; 96) '{     ...d(); }': ()
    [83; 84) 't': T
-    [83; 93) 't.method()': [missing name]
+    [83; 93) 't.method()': U
    "###
    );
 }
@@ -728,7 +728,7 @@ fn test() {
    [157; 158) 'S': S
    [157; 165) 'S.into()': u64
    [175; 176) 'z': u64
-    [179; 196) 'Into::...::into': fn into<S, u64>(Self) -> T
+    [179; 196) 'Into::...::into': fn into<S, u64>(S) -> u64
    [179; 199) 'Into::...nto(S)': u64
    [197; 198) 'S': S
    "###
diff --git a/crates/ra_hir_ty/src/tests/never_type.rs b/crates/ra_hir_ty/src/tests/never_type.rs
index c202f545a..a77209480 100644
--- a/crates/ra_hir_ty/src/tests/never_type.rs
+++ b/crates/ra_hir_ty/src/tests/never_type.rs
@@ -101,6 +101,7 @@ fn test() {
    );
    assert_eq!(t, "Option<i32>");
 }
 #[test]
 fn never_type_can_be_reinferred3() {
    let t = type_at(
@@ -138,6 +139,22 @@ fn test(a: Void) {
 }
 #[test]
+fn match_unknown_arm() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(a: Option) {
+    let t = match 0 {
+        _ => unknown,
+    };
+    t<|>;
+}
+"#,
+    );
+    assert_eq!(t, "{unknown}");
+}
+#[test]
 fn if_never() {
    let t = type_at(
        r#"
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index cb3890b42..e25d6dbc4 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -96,13 +96,13 @@ fn test() {
    [38; 42) 'A(n)': A<i32>
    [40; 41) 'n': &i32
    [45; 50) '&A(1)': &A<i32>
-    [46; 47) 'A': A<i32>(T) -> A<T>
+    [46; 47) 'A': A<i32>(i32) -> A<i32>
    [46; 50) 'A(1)': A<i32>
    [48; 49) '1': i32
    [60; 64) 'A(n)': A<i32>
    [62; 63) 'n': &mut i32
    [67; 76) '&mut A(1)': &mut A<i32>
-    [72; 73) 'A': A<i32>(T) -> A<T>
+    [72; 73) 'A': A<i32>(i32) -> A<i32>
    [72; 76) 'A(1)': A<i32>
    [74; 75) '1': i32
    "###
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 02bab6dbe..14c8ed3a9 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -346,7 +346,7 @@ pub fn main_loop() {
    @r###"
    [144; 146) '{}': ()
    [169; 198) '{     ...t(); }': ()
-    [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<T, H>
+    [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher>
    [175; 195) 'FxHash...ault()': HashSet<{unknown}, FxHasher>
    "###
    );
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index fdab9c187..3803f5938 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -754,15 +754,15 @@ fn test() {
    [289; 295) 'self.0': T
    [315; 353) '{     ...))); }': ()
    [325; 326) 't': &i32
-    [329; 335) 'A::foo': fn foo<i32>(&A<T>) -> &T
+    [329; 335) 'A::foo': fn foo<i32>(&A<i32>) -> &i32
    [329; 350) 'A::foo...42))))': &i32
    [336; 349) '&&B(B(A(42)))': &&B<B<A<i32>>>
    [337; 349) '&B(B(A(42)))': &B<B<A<i32>>>
-    [338; 339) 'B': B<B<A<i32>>>(T) -> B<T>
+    [338; 339) 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
    [338; 349) 'B(B(A(42)))': B<B<A<i32>>>
-    [340; 341) 'B': B<A<i32>>(T) -> B<T>
+    [340; 341) 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
    [340; 348) 'B(A(42))': B<A<i32>>
-    [342; 343) 'A': A<i32>(T) -> A<T>
+    [342; 343) 'A': A<i32>(i32) -> A<i32>
    [342; 347) 'A(42)': A<i32>
    [344; 346) '42': i32
    "###
@@ -817,16 +817,16 @@ fn test(a: A<i32>) {
    [326; 327) 'a': A<i32>
    [337; 383) '{     ...))); }': ()
    [347; 348) 't': &i32
-    [351; 352) 'A': A<i32>(*mut T) -> A<T>
+    [351; 352) 'A': A<i32>(*mut i32) -> A<i32>
    [351; 365) 'A(0 as *mut _)': A<i32>
    [351; 380) 'A(0 as...B(a)))': &i32
    [353; 354) '0': i32
    [353; 364) '0 as *mut _': *mut i32
    [370; 379) '&&B(B(a))': &&B<B<A<i32>>>
    [371; 379) '&B(B(a))': &B<B<A<i32>>>
-    [372; 373) 'B': B<B<A<i32>>>(T) -> B<T>
+    [372; 373) 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
    [372; 379) 'B(B(a))': B<B<A<i32>>>
-    [374; 375) 'B': B<A<i32>>(T) -> B<T>
+    [374; 375) 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
    [374; 378) 'B(a)': B<A<i32>>
    [376; 377) 'a': A<i32>
    "###
@@ -1169,16 +1169,16 @@ fn test() {
 "#),
        @r###"
    [76; 184) '{     ...one; }': ()
-    [82; 83) 'A': A<i32>(T) -> A<T>
+    [82; 83) 'A': A<i32>(i32) -> A<i32>
    [82; 87) 'A(42)': A<i32>
    [84; 86) '42': i32
-    [93; 94) 'A': A<u128>(T) -> A<T>
+    [93; 94) 'A': A<u128>(u128) -> A<u128>
    [93; 102) 'A(42u128)': A<u128>
    [95; 101) '42u128': u128
-    [108; 112) 'Some': Some<&str>(T) -> Option<T>
+    [108; 112) 'Some': Some<&str>(&str) -> Option<&str>
    [108; 117) 'Some("x")': Option<&str>
    [113; 116) '"x"': &str
-    [123; 135) 'Option::Some': Some<&str>(T) -> Option<T>
+    [123; 135) 'Option::Some': Some<&str>(&str) -> Option<&str>
    [123; 140) 'Option...e("x")': Option<&str>
    [136; 139) '"x"': &str
    [146; 150) 'None': Option<{unknown}>
@@ -1205,14 +1205,14 @@ fn test() {
    [21; 26) '{ t }': T
    [23; 24) 't': T
    [38; 98) '{     ...(1); }': ()
-    [44; 46) 'id': fn id<u32>(T) -> T
+    [44; 46) 'id': fn id<u32>(u32) -> u32
    [44; 52) 'id(1u32)': u32
    [47; 51) '1u32': u32
-    [58; 68) 'id::<i128>': fn id<i128>(T) -> T
+    [58; 68) 'id::<i128>': fn id<i128>(i128) -> i128
    [58; 71) 'id::<i128>(1)': i128
    [69; 70) '1': i128
    [81; 82) 'x': u64
-    [90; 92) 'id': fn id<u64>(T) -> T
+    [90; 92) 'id': fn id<u64>(u64) -> u64
    [90; 95) 'id(1)': u64
    [93; 94) '1': u64
    "###
@@ -1220,7 +1220,7 @@ fn test() {
 }
 #[test]
-fn infer_impl_generics() {
+fn infer_impl_generics_basic() {
    assert_snapshot!(
        infer(r#"
 struct A<T1, T2> {
@@ -1349,16 +1349,16 @@ fn test() -> i128 {
    [146; 147) 'x': i128
    [150; 151) '1': i128
    [162; 163) 'y': i128
-    [166; 168) 'id': fn id<i128>(T) -> T
+    [166; 168) 'id': fn id<i128>(i128) -> i128
    [166; 171) 'id(x)': i128
    [169; 170) 'x': i128
    [182; 183) 'a': A<i128>
    [186; 200) 'A { x: id(y) }': A<i128>
-    [193; 195) 'id': fn id<i128>(T) -> T
+    [193; 195) 'id': fn id<i128>(i128) -> i128
    [193; 198) 'id(y)': i128
    [196; 197) 'y': i128
    [211; 212) 'z': i128
-    [215; 217) 'id': fn id<i128>(T) -> T
+    [215; 217) 'id': fn id<i128>(i128) -> i128
    [215; 222) 'id(a.x)': i128
    [218; 219) 'a': A<i128>
    [218; 221) 'a.x': i128
@@ -1502,14 +1502,14 @@ fn test() {
    [78; 158) '{     ...(1); }': ()
    [88; 89) 'y': u32
    [92; 97) '10u32': u32
-    [103; 105) 'id': fn id<u32>(T) -> T
+    [103; 105) 'id': fn id<u32>(u32) -> u32
    [103; 108) 'id(y)': u32
    [106; 107) 'y': u32
    [118; 119) 'x': bool
-    [128; 133) 'clone': fn clone<bool>(&T) -> T
+    [128; 133) 'clone': fn clone<bool>(&bool) -> bool
    [128; 136) 'clone(z)': bool
    [134; 135) 'z': &bool
-    [142; 152) 'id::<i128>': fn id<i128>(T) -> T
+    [142; 152) 'id::<i128>': fn id<i128>(i128) -> i128
    [142; 155) 'id::<i128>(1)': i128
    [153; 154) '1': i128
    "###
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index a6ac18f86..17611ddbf 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,7 +1,6 @@
 use insta::assert_snapshot;
 use ra_db::fixture::WithFixture;
-use test_utils::covers;
 use super::{infer, infer_with_mismatches, type_at, type_at_pos};
 use crate::test_db::TestDB;
@@ -261,10 +260,10 @@ fn test() {
    [92; 94) '{}': ()
    [105; 144) '{     ...(s); }': ()
    [115; 116) 's': S<u32>
-    [119; 120) 'S': S<u32>(T) -> S<T>
+    [119; 120) 'S': S<u32>(u32) -> S<u32>
    [119; 129) 'S(unknown)': S<u32>
    [121; 128) 'unknown': u32
-    [135; 138) 'foo': fn foo<S<u32>>(T) -> ()
+    [135; 138) 'foo': fn foo<S<u32>>(S<u32>) -> ()
    [135; 141) 'foo(s)': ()
    [139; 140) 's': S<u32>
    "###
@@ -289,11 +288,11 @@ fn test() {
    [98; 100) '{}': ()
    [111; 163) '{     ...(s); }': ()
    [121; 122) 's': S<u32>
-    [125; 126) 'S': S<u32>(T) -> S<T>
+    [125; 126) 'S': S<u32>(u32) -> S<u32>
    [125; 135) 'S(unknown)': S<u32>
    [127; 134) 'unknown': u32
    [145; 146) 'x': u32
-    [154; 157) 'foo': fn foo<u32, S<u32>>(T) -> U
+    [154; 157) 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
    [154; 160) 'foo(s)': u32
    [158; 159) 's': S<u32>
    "###
@@ -358,15 +357,15 @@ fn test() {
    [221; 223) '{}': ()
    [234; 300) '{     ...(S); }': ()
    [244; 245) 'x': u32
-    [248; 252) 'foo1': fn foo1<S>(T) -> <T as Iterable>::Item
+    [248; 252) 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
    [248; 255) 'foo1(S)': u32
    [253; 254) 'S': S
    [265; 266) 'y': u32
-    [269; 273) 'foo2': fn foo2<S>(T) -> <T as Iterable>::Item
+    [269; 273) 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
    [269; 276) 'foo2(S)': u32
    [274; 275) 'S': S
    [286; 287) 'z': u32
-    [290; 294) 'foo3': fn foo3<S>(T) -> <T as Iterable>::Item
+    [290; 294) 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
    [290; 297) 'foo3(S)': u32
    [295; 296) 'S': S
    "###
@@ -822,8 +821,7 @@ fn test<T: ApplyL>() {
 "#,
    );
    // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
-    // FIXME: fix type parameter names going missing when going through Chalk
+    assert_eq!(t, "ApplyL::Out<T>");
-    assert_eq!(t, "ApplyL::Out<[missing name]>");
 }
 #[test]
@@ -850,6 +848,197 @@ fn test<T: ApplyL>(t: T) {
 }
 #[test]
+fn argument_impl_trait() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait<T> {
+    fn foo(&self) -> T;
+    fn foo2(&self) -> i64;
+}
+fn bar(x: impl Trait<u16>) {}
+struct S<T>(T);
+impl<T> Trait<T> for S<T> {}
+fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
+    x;
+    y;
+    let z = S(1);
+    bar(z);
+    x.foo();
+    y.foo();
+    z.foo();
+    x.foo2();
+    y.foo2();
+    z.foo2();
+}
+"#, true),
+        @r###"
+    [30; 34) 'self': &Self
+    [55; 59) 'self': &Self
+    [78; 79) 'x': impl Trait<u16>
+    [98; 100) '{}': ()
+    [155; 156) 'x': impl Trait<u64>
+    [175; 176) 'y': &impl Trait<u32>
+    [196; 324) '{     ...2(); }': ()
+    [202; 203) 'x': impl Trait<u64>
+    [209; 210) 'y': &impl Trait<u32>
+    [220; 221) 'z': S<u16>
+    [224; 225) 'S': S<u16>(u16) -> S<u16>
+    [224; 228) 'S(1)': S<u16>
+    [226; 227) '1': u16
+    [234; 237) 'bar': fn bar(S<u16>) -> ()
+    [234; 240) 'bar(z)': ()
+    [238; 239) 'z': S<u16>
+    [246; 247) 'x': impl Trait<u64>
+    [246; 253) 'x.foo()': u64
+    [259; 260) 'y': &impl Trait<u32>
+    [259; 266) 'y.foo()': u32
+    [272; 273) 'z': S<u16>
+    [272; 279) 'z.foo()': u16
+    [285; 286) 'x': impl Trait<u64>
+    [285; 293) 'x.foo2()': i64
+    [299; 300) 'y': &impl Trait<u32>
+    [299; 307) 'y.foo2()': i64
+    [313; 314) 'z': S<u16>
+    [313; 321) 'z.foo2()': i64
+    "###
+    );
+}
+#[test]
+fn argument_impl_trait_type_args_1() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+trait Foo {
+    // this function has an implicit Self param, an explicit type param,
+    // and an implicit impl Trait param!
+    fn bar<T>(x: impl Trait) -> T { loop {} }
+}
+fn foo<T>(x: impl Trait) -> T { loop {} }
+struct S;
+impl Trait for S {}
+struct F;
+impl Foo for F {}
+fn test() {
+    Foo::bar(S);
+    <F as Foo>::bar(S);
+    F::bar(S);
+    Foo::bar::<u32>(S);
+    <F as Foo>::bar::<u32>(S);
+    foo(S);
+    foo::<u32>(S);
+    foo::<u32, i32>(S); // we should ignore the extraneous i32
+}
+"#, true),
+        @r###"
+    [156; 157) 'x': impl Trait
+    [176; 187) '{ loop {} }': T
+    [178; 185) 'loop {}': !
+    [183; 185) '{}': ()
+    [200; 201) 'x': impl Trait
+    [220; 231) '{ loop {} }': T
+    [222; 229) 'loop {}': !
+    [227; 229) '{}': ()
+    [301; 510) '{     ... i32 }': ()
+    [307; 315) 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
+    [307; 318) 'Foo::bar(S)': {unknown}
+    [316; 317) 'S': S
+    [324; 339) '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
+    [324; 342) '<F as ...bar(S)': {unknown}
+    [340; 341) 'S': S
+    [348; 354) 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
+    [348; 357) 'F::bar(S)': {unknown}
+    [355; 356) 'S': S
+    [363; 378) 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
+    [363; 381) 'Foo::b...32>(S)': u32
+    [379; 380) 'S': S
+    [387; 409) '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
+    [387; 412) '<F as ...32>(S)': u32
+    [410; 411) 'S': S
+    [419; 422) 'foo': fn foo<{unknown}>(S) -> {unknown}
+    [419; 425) 'foo(S)': {unknown}
+    [423; 424) 'S': S
+    [431; 441) 'foo::<u32>': fn foo<u32>(S) -> u32
+    [431; 444) 'foo::<u32>(S)': u32
+    [442; 443) 'S': S
+    [450; 465) 'foo::<u32, i32>': fn foo<u32>(S) -> u32
+    [450; 468) 'foo::<...32>(S)': u32
+    [466; 467) 'S': S
+    "###
+    );
+}
+#[test]
+fn argument_impl_trait_type_args_2() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+struct S;
+impl Trait for S {}
+struct F<T>;
+impl<T> F<T> {
+    fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
+}
+fn test() {
+    F.foo(S);
+    F::<u32>.foo(S);
+    F::<u32>.foo::<i32>(S);
+    F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
+}
+"#, true),
+        @r###"
+    [88; 92) 'self': F<T>
+    [94; 95) 'x': impl Trait
+    [119; 130) '{ loop {} }': (T, U)
+    [121; 128) 'loop {}': !
+    [126; 128) '{}': ()
+    [144; 284) '{     ...ored }': ()
+    [150; 151) 'F': F<{unknown}>
+    [150; 158) 'F.foo(S)': ({unknown}, {unknown})
+    [156; 157) 'S': S
+    [164; 172) 'F::<u32>': F<u32>
+    [164; 179) 'F::<u32>.foo(S)': (u32, {unknown})
+    [177; 178) 'S': S
+    [185; 193) 'F::<u32>': F<u32>
+    [185; 207) 'F::<u3...32>(S)': (u32, i32)
+    [205; 206) 'S': S
+    [213; 221) 'F::<u32>': F<u32>
+    [213; 240) 'F::<u3...32>(S)': (u32, i32)
+    [238; 239) 'S': S
+    "###
+    );
+}
+#[test]
+fn argument_impl_trait_to_fn_pointer() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+fn foo(x: impl Trait) { loop {} }
+struct S;
+impl Trait for S {}
+fn test() {
+    let f: fn(S) -> () = foo;
+}
+"#, true),
+        @r###"
+    [23; 24) 'x': impl Trait
+    [38; 49) '{ loop {} }': ()
+    [40; 47) 'loop {}': !
+    [45; 47) '{}': ()
+    [91; 124) '{     ...foo; }': ()
+    [101; 102) 'f': fn(S) -> ()
+    [118; 121) 'foo': fn foo(S) -> ()
+    "###
+    );
+}
+#[test]
 #[ignore]
 fn impl_trait() {
    assert_snapshot!(
@@ -994,29 +1183,17 @@ fn weird_bounds() {
    assert_snapshot!(
        infer(r#"
 trait Trait {}
-fn test() {
+fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {
-    let a: impl Trait + 'lifetime = foo;
-    let b: impl 'lifetime = foo;
-    let b: impl (Trait) = foo;
-    let b: impl ('lifetime) = foo;
-    let d: impl ?Sized = foo;
-    let e: impl Trait + ?Sized = foo;
 }
 "#),
        @r###"
-    [26; 237) '{     ...foo; }': ()
+    [24; 25) 'a': impl Trait + {error}
-    [36; 37) 'a': impl Trait + {error}
+    [51; 52) 'b': impl {error}
-    [64; 67) 'foo': impl Trait + {error}
+    [70; 71) 'c': impl Trait
-    [77; 78) 'b': impl {error}
+    [87; 88) 'd': impl {error}
-    [97; 100) 'foo': impl {error}
+    [108; 109) 'e': impl {error}
-    [110; 111) 'b': impl Trait
+    [124; 125) 'f': impl Trait + {error}
-    [128; 131) 'foo': impl Trait
+    [148; 151) '{ }': ()
-    [141; 142) 'b': impl {error}
-    [163; 166) 'foo': impl {error}
-    [176; 177) 'd': impl {error}
-    [193; 196) 'foo': impl {error}
-    [206; 207) 'e': impl Trait + {error}
-    [231; 234) 'foo': impl Trait + {error}
    "###
    );
 }
@@ -1078,26 +1255,26 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
    [296; 299) 'get': fn get<T>(T) -> <T as Trait>::Type
    [296; 302) 'get(x)': {unknown}
    [300; 301) 'x': T
-    [308; 312) 'get2': fn get2<{unknown}, T>(T) -> U
+    [308; 312) 'get2': fn get2<{unknown}, T>(T) -> {unknown}
    [308; 315) 'get2(x)': {unknown}
    [313; 314) 'x': T
-    [321; 324) 'get': fn get<impl Trait<Type = i64>>(T) -> <T as Trait>::Type
+    [321; 324) 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
    [321; 327) 'get(y)': {unknown}
    [325; 326) 'y': impl Trait<Type = i64>
-    [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(T) -> U
+    [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> {unknown}
    [333; 340) 'get2(y)': {unknown}
    [338; 339) 'y': impl Trait<Type = i64>
-    [346; 349) 'get': fn get<S<u64>>(T) -> <T as Trait>::Type
+    [346; 349) 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
    [346; 357) 'get(set(S))': u64
-    [350; 353) 'set': fn set<S<u64>>(T) -> T
+    [350; 353) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
    [350; 356) 'set(S)': S<u64>
    [354; 355) 'S': S<u64>
-    [363; 367) 'get2': fn get2<u64, S<u64>>(T) -> U
+    [363; 367) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
    [363; 375) 'get2(set(S))': u64
-    [368; 371) 'set': fn set<S<u64>>(T) -> T
+    [368; 371) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
    [368; 374) 'set(S)': S<u64>
    [372; 373) 'S': S<u64>
-    [381; 385) 'get2': fn get2<str, S<str>>(T) -> U
+    [381; 385) 'get2': fn get2<str, S<str>>(S<str>) -> str
    [381; 395) 'get2(S::<str>)': str
    [386; 394) 'S::<str>': S<str>
    "###
@@ -1225,6 +1402,32 @@ fn test<T: Trait1, U: Trait2>(x: T, y: U) {
 }
 #[test]
+fn super_trait_impl_trait_method_resolution() {
+    assert_snapshot!(
+        infer(r#"
+mod foo {
+    trait SuperTrait {
+        fn foo(&self) -> u32 {}
+    }
+}
+trait Trait1: foo::SuperTrait {}
+fn test(x: &impl Trait1) {
+    x.foo();
+}
+"#),
+        @r###"
+    [50; 54) 'self': &Self
+    [63; 65) '{}': ()
+    [116; 117) 'x': &impl Trait1
+    [133; 149) '{     ...o(); }': ()
+    [139; 140) 'x': &impl Trait1
+    [139; 146) 'x.foo()': u32
+    "###
+    );
+}
+#[test]
 fn super_trait_cycle() {
    // This just needs to not crash
    assert_snapshot!(
@@ -1270,9 +1473,9 @@ fn test() {
    [157; 160) '{t}': T
    [158; 159) 't': T
    [259; 280) '{     ...S)); }': ()
-    [265; 269) 'get2': fn get2<u64, S<u64>>(T) -> U
+    [265; 269) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
    [265; 277) 'get2(set(S))': u64
-    [270; 273) 'set': fn set<S<u64>>(T) -> T
+    [270; 273) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
    [270; 276) 'set(S)': S<u64>
    [274; 275) 'S': S<u64>
    "###
@@ -1334,7 +1537,7 @@ fn test() {
    [173; 175) '{}': ()
    [189; 308) '{     ... 1); }': ()
    [199; 200) 'x': Option<u32>
-    [203; 215) 'Option::Some': Some<u32>(T) -> Option<T>
+    [203; 215) 'Option::Some': Some<u32>(u32) -> Option<u32>
    [203; 221) 'Option...(1u32)': Option<u32>
    [216; 220) '1u32': u32
    [227; 228) 'x': Option<u32>
@@ -1444,7 +1647,7 @@ fn test() {
    [340; 342) '{}': ()
    [356; 515) '{     ... S); }': ()
    [366; 368) 'x1': u64
-    [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(T, F) -> U
+    [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
    [371; 394) 'foo1(S...hod())': u64
    [376; 377) 'S': S
    [379; 393) '|s| s.method()': |S| -> u64
@@ -1452,7 +1655,7 @@ fn test() {
    [383; 384) 's': S
    [383; 393) 's.method()': u64
    [404; 406) 'x2': u64
-    [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(F, T) -> U
+    [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
    [409; 432) 'foo2(|...(), S)': u64
    [414; 428) '|s| s.method()': |S| -> u64
    [415; 416) 's': S
@@ -1605,7 +1808,6 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 #[test]
 fn unify_impl_trait() {
-    covers!(insert_vars_for_impl_trait);
    assert_snapshot!(
        infer_with_mismatches(r#"
 trait Trait<T> {}
@@ -1637,26 +1839,26 @@ fn test() -> impl Trait<i32> {
    [172; 183) '{ loop {} }': T
    [174; 181) 'loop {}': !
    [179; 181) '{}': ()
-    [214; 310) '{     ...t()) }': S<i32>
+    [214; 310) '{     ...t()) }': S<{unknown}>
    [224; 226) 's1': S<u32>
-    [229; 230) 'S': S<u32>(T) -> S<T>
+    [229; 230) 'S': S<u32>(u32) -> S<u32>
    [229; 241) 'S(default())': S<u32>
-    [231; 238) 'default': fn default<u32>() -> T
+    [231; 238) 'default': fn default<u32>() -> u32
    [231; 240) 'default()': u32
-    [247; 250) 'foo': fn foo(impl Trait<u32>) -> ()
+    [247; 250) 'foo': fn foo(S<u32>) -> ()
    [247; 254) 'foo(s1)': ()
    [251; 253) 's1': S<u32>
    [264; 265) 'x': i32
-    [273; 276) 'bar': fn bar<i32>(impl Trait<T>) -> T
+    [273; 276) 'bar': fn bar<i32>(S<i32>) -> i32
    [273; 290) 'bar(S(...lt()))': i32
-    [277; 278) 'S': S<i32>(T) -> S<T>
+    [277; 278) 'S': S<i32>(i32) -> S<i32>
    [277; 289) 'S(default())': S<i32>
-    [279; 286) 'default': fn default<i32>() -> T
+    [279; 286) 'default': fn default<i32>() -> i32
    [279; 288) 'default()': i32
-    [296; 297) 'S': S<i32>(T) -> S<T>
+    [296; 297) 'S': S<{unknown}>({unknown}) -> S<{unknown}>
-    [296; 308) 'S(default())': S<i32>
+    [296; 308) 'S(default())': S<{unknown}>
-    [298; 305) 'default': fn default<i32>() -> T
+    [298; 305) 'default': fn default<{unknown}>() -> {unknown}
-    [298; 307) 'default()': i32
+    [298; 307) 'default()': {unknown}
    "###
    );
 }
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index fe9cb556c..4974c565b 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -14,7 +14,7 @@ use ra_db::{
 use super::{builtin, AssocTyValue, Canonical, ChalkContext, Impl, Obligation};
 use crate::{
    db::HirDatabase, display::HirDisplay, utils::generics, ApplicationTy, GenericPredicate,
-    ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
+    ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
@@ -142,9 +142,13 @@ impl ToChalk for Ty {
                let substitution = proj_ty.parameters.to_chalk(db);
                chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern()
            }
-            Ty::Param { idx, .. } => {
+            Ty::Param(id) => {
-                PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }
+                let interned_id = db.intern_type_param_id(id);
-                    .to_ty::<TypeFamily>()
+                PlaceholderIndex {
+                    ui: UniverseIndex::ROOT,
+                    idx: interned_id.as_intern_id().as_usize(),
+                }
+                .to_ty::<TypeFamily>()
            }
            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
@@ -177,7 +181,10 @@ impl ToChalk for Ty {
            },
            chalk_ir::TyData::Placeholder(idx) => {
                assert_eq!(idx.ui, UniverseIndex::ROOT);
-                Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() }
+                let interned_id = crate::db::GlobalTypeParamId::from_intern_id(
+                    crate::salsa::InternId::from(idx.idx),
+                );
+                Ty::Param(db.lookup_intern_type_param_id(interned_id))
            }
            chalk_ir::TyData::Alias(proj) => {
                let associated_ty = from_chalk(db, proj.associated_ty_id);
@@ -520,7 +527,7 @@ fn convert_where_clauses(
    let generic_predicates = db.generic_predicates(def);
    let mut result = Vec::with_capacity(generic_predicates.len());
    for pred in generic_predicates.iter() {
-        if pred.is_error() {
+        if pred.value.is_error() {
            // skip errored predicates completely
            continue;
        }
@@ -709,12 +716,12 @@ fn impl_block_datum(
    let trait_ref = db
        .impl_trait(impl_id)
        // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
-        .expect("invalid impl passed to Chalk");
+        .expect("invalid impl passed to Chalk")
+        .value;
    let impl_data = db.impl_data(impl_id);
    let generic_params = generics(db, impl_id.into());
    let bound_vars = Substs::bound_vars(&generic_params);
-    let trait_ref = trait_ref.subst(&bound_vars);
    let trait_ = trait_ref.trait_;
    let impl_type = if impl_id.lookup(db).container.module(db).krate == krate {
        chalk_rust_ir::ImplType::Local
@@ -789,20 +796,18 @@ fn type_alias_associated_ty_value(
        _ => panic!("assoc ty value should be in impl"),
    };
-    let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist"); // we don't return any assoc ty values if the impl'd trait can't be resolved
+    let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist").value; // we don't return any assoc ty values if the impl'd trait can't be resolved
    let assoc_ty = db
        .trait_data(trait_ref.trait_)
        .associated_type_by_name(&type_alias_data.name)
        .expect("assoc ty value should not exist"); // validated when building the impl data as well
-    let generic_params = generics(db, impl_id.into());
+    let ty = db.ty(type_alias.into());
-    let bound_vars = Substs::bound_vars(&generic_params);
+    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) };
-    let ty = db.ty(type_alias.into()).subst(&bound_vars);
-    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
    let value = chalk_rust_ir::AssociatedTyValue {
        impl_id: Impl::ImplBlock(impl_id.into()).to_chalk(db),
        associated_ty_id: assoc_ty.to_chalk(db),
-        value: make_binders(value_bound, bound_vars.len()),
+        value: make_binders(value_bound, ty.num_binders),
    };
    Arc::new(value)
 }
diff --git a/crates/ra_hir_ty/src/utils.rs b/crates/ra_hir_ty/src/utils.rs
index 0b1806a84..508ae9046 100644
--- a/crates/ra_hir_ty/src/utils.rs
+++ b/crates/ra_hir_ty/src/utils.rs
@@ -2,10 +2,11 @@
 //! query, but can't be computed directly from `*Data` (ie, which need a `db`).
 use std::sync::Arc;
+use hir_def::generics::WherePredicateTarget;
 use hir_def::{
    adt::VariantData,
    db::DefDatabase,
-    generics::{GenericParams, TypeParamData},
+    generics::{GenericParams, TypeParamData, TypeParamProvenance},
    path::Path,
    resolver::{HasResolver, TypeNs},
    type_ref::TypeRef,
@@ -19,11 +20,18 @@ fn direct_super_traits(db: &impl DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    // lifetime problems, but since there usually shouldn't be more than a
    // few direct traits this should be fine (we could even use some kind of
    // SmallVec if performance is a concern)
-    db.generic_params(trait_.into())
+    let generic_params = db.generic_params(trait_.into());
+    let trait_self = generic_params.find_trait_self_param();
+    generic_params
        .where_predicates
        .iter()
-        .filter_map(|pred| match &pred.type_ref {
+        .filter_map(|pred| match &pred.target {
-            TypeRef::Path(p) if p == &Path::from(name![Self]) => pred.bound.as_path(),
+            WherePredicateTarget::TypeRef(TypeRef::Path(p)) if p == &Path::from(name![Self]) => {
+                pred.bound.as_path()
+            }
+            WherePredicateTarget::TypeParam(local_id) if Some(*local_id) == trait_self => {
+                pred.bound.as_path()
+            }
            _ => None,
        })
        .filter_map(|path| match resolver.resolve_path_in_type_ns_fully(db, path.mod_path()) {
@@ -95,41 +103,77 @@ pub(crate) struct Generics {
 }
 impl Generics {
-    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = (u32, &'a TypeParamData)> + 'a {
+    pub(crate) fn iter<'a>(
+        &'a self,
+    ) -> impl Iterator<Item = (TypeParamId, &'a TypeParamData)> + 'a {
        self.parent_generics
            .as_ref()
            .into_iter()
-            .flat_map(|it| it.params.types.iter())
+            .flat_map(|it| {
-            .chain(self.params.types.iter())
+                it.params
-            .enumerate()
+                    .types
-            .map(|(i, (_local_id, p))| (i as u32, p))
+                    .iter()
+                    .map(move |(local_id, p)| (TypeParamId { parent: it.def, local_id }, p))
+            })
+            .chain(
+                self.params
+                    .types
+                    .iter()
+                    .map(move |(local_id, p)| (TypeParamId { parent: self.def, local_id }, p)),
+            )
    }
-    pub(crate) fn iter_parent<'a>(&'a self) -> impl Iterator<Item = (u32, &'a TypeParamData)> + 'a {
+    pub(crate) fn iter_parent<'a>(
-        self.parent_generics
+        &'a self,
-            .as_ref()
+    ) -> impl Iterator<Item = (TypeParamId, &'a TypeParamData)> + 'a {
-            .into_iter()
+        self.parent_generics.as_ref().into_iter().flat_map(|it| {
-            .flat_map(|it| it.params.types.iter())
+            it.params
-            .enumerate()
+                .types
-            .map(|(i, (_local_id, p))| (i as u32, p))
+                .iter()
+                .map(move |(local_id, p)| (TypeParamId { parent: it.def, local_id }, p))
+        })
    }
    pub(crate) fn len(&self) -> usize {
        self.len_split().0
    }
    /// (total, parents, child)
    pub(crate) fn len_split(&self) -> (usize, usize, usize) {
        let parent = self.parent_generics.as_ref().map_or(0, |p| p.len());
        let child = self.params.types.len();
        (parent + child, parent, child)
    }
-    pub(crate) fn param_idx(&self, param: TypeParamId) -> u32 {
-        self.find_param(param).0
+    /// (parent total, self param, type param list, impl trait)
+    pub(crate) fn provenance_split(&self) -> (usize, usize, usize, usize) {
+        let parent = self.parent_generics.as_ref().map_or(0, |p| p.len());
+        let self_params = self
+            .params
+            .types
+            .iter()
+            .filter(|(_, p)| p.provenance == TypeParamProvenance::TraitSelf)
+            .count();
+        let list_params = self
+            .params
+            .types
+            .iter()
+            .filter(|(_, p)| p.provenance == TypeParamProvenance::TypeParamList)
+            .count();
+        let impl_trait_params = self
+            .params
+            .types
+            .iter()
+            .filter(|(_, p)| p.provenance == TypeParamProvenance::ArgumentImplTrait)
+            .count();
+        (parent, self_params, list_params, impl_trait_params)
    }
-    pub(crate) fn param_name(&self, param: TypeParamId) -> Name {
-        self.find_param(param).1.name.clone()
+    pub(crate) fn param_idx(&self, param: TypeParamId) -> Option<u32> {
+        Some(self.find_param(param)?.0)
    }
-    fn find_param(&self, param: TypeParamId) -> (u32, &TypeParamData) {
+    fn find_param(&self, param: TypeParamId) -> Option<(u32, &TypeParamData)> {
        if param.parent == self.def {
            let (idx, (_local_id, data)) = self
                .params
@@ -139,9 +183,10 @@ impl Generics {
                .find(|(_, (idx, _))| *idx == param.local_id)
                .unwrap();
            let (_total, parent_len, _child) = self.len_split();
-            return ((parent_len + idx) as u32, data);
+            Some(((parent_len + idx) as u32, data))
+        } else {
+            self.parent_generics.as_ref().and_then(|g| g.find_param(param))
        }
-        self.parent_generics.as_ref().unwrap().find_param(param)
    }
 }
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
index b60b1a60d..40d56a4f7 100644
--- a/crates/ra_ide/src/assists.rs
+++ b/crates/ra_ide/src/assists.rs
@@ -1,6 +1,5 @@
 //! FIXME: write short doc here
-use either::Either;
 use ra_assists::{resolved_assists, AssistAction, AssistLabel};
 use ra_db::{FilePosition, FileRange};
 use ra_ide_db::RootDatabase;
@@ -13,7 +12,8 @@ pub use ra_assists::AssistId;
 pub struct Assist {
    pub id: AssistId,
    pub label: String,
-    pub change_data: Either<SourceChange, Vec<SourceChange>>,
+    pub group_label: Option<String>,
+    pub source_change: SourceChange,
 }
 pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
@@ -25,17 +25,8 @@ pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
            Assist {
                id: assist_label.id,
                label: assist_label.label.clone(),
-                change_data: match assist.action_data {
+                group_label: assist.group_label.map(|it| it.0),
-                    Either::Left(action) => {
+                source_change: action_to_edit(assist.action, file_id, assist_label),
-                        Either::Left(action_to_edit(action, file_id, assist_label))
-                    }
-                    Either::Right(actions) => Either::Right(
-                        actions
-                            .into_iter()
-                            .map(|action| action_to_edit(action, file_id, assist_label))
-                            .collect(),
-                    ),
-                },
            }
        })
        .collect()
@@ -47,9 +38,6 @@ fn action_to_edit(
    assist_label: &AssistLabel,
 ) -> SourceChange {
    let file_edit = SourceFileEdit { file_id, edit: action.edit };
-    SourceChange::source_file_edit(
+    SourceChange::source_file_edit(assist_label.label.clone(), file_edit)
-        action.label.unwrap_or_else(|| assist_label.label.clone()),
+        .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
-        file_edit,
-    )
-    .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
 }
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index 64b04ec2b..e2ee86dd1 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -1,12 +1,6 @@
 //! FIXME: write short doc here
-use ra_assists::auto_import_text_edit;
+use crate::completion::{CompletionContext, Completions};
-use ra_syntax::{ast, AstNode, SmolStr};
-use ra_text_edit::TextEditBuilder;
-use rustc_hash::FxHashMap;
-use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
-use hir::{ModPath, PathKind};
 pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
    if !ctx.is_trivial_path {
@@ -16,138 +10,14 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
    ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
        acc.add_resolution(ctx, name.to_string(), &res)
    });
-    // auto-import
-    // We fetch ident from the original file, because we need to pre-filter auto-imports
-    if ast::NameRef::cast(ctx.token.parent()).is_some() {
-        let import_resolver = ImportResolver::new();
-        let import_names = import_resolver.all_names(ctx.token.text());
-        import_names.into_iter().for_each(|(name, path)| {
-            let edit = {
-                let mut builder = TextEditBuilder::default();
-                builder.replace(ctx.source_range(), name.to_string());
-                auto_import_text_edit(
-                    &ctx.token.parent(),
-                    &ctx.token.parent(),
-                    &path,
-                    &mut builder,
-                );
-                builder.finish()
-            };
-            // Hack: copied this check form conv.rs beacause auto import can produce edits
-            // that invalidate assert in conv_with.
-            if edit
-                .as_atoms()
-                .iter()
-                .filter(|atom| !ctx.source_range().is_subrange(&atom.delete))
-                .all(|atom| ctx.source_range().intersection(&atom.delete).is_none())
-            {
-                CompletionItem::new(
-                    CompletionKind::Reference,
-                    ctx.source_range(),
-                    build_import_label(&name, &path),
-                )
-                .text_edit(edit)
-                .add_to(acc);
-            }
-        });
-    }
-}
-fn build_import_label(name: &str, path: &ModPath) -> String {
-    let mut buf = String::with_capacity(64);
-    buf.push_str(name);
-    buf.push_str(" (");
-    buf.push_str(&path.to_string());
-    buf.push_str(")");
-    buf
-}
-#[derive(Debug, Clone, Default)]
-pub(crate) struct ImportResolver {
-    // todo: use fst crate or something like that
-    dummy_names: Vec<(SmolStr, ModPath)>,
-}
-impl ImportResolver {
-    pub(crate) fn new() -> Self {
-        use hir::name;
-        let dummy_names = vec![
-            (
-                SmolStr::new("fmt"),
-                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![fmt]] },
-            ),
-            (
-                SmolStr::new("io"),
-                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![io]] },
-            ),
-            (
-                SmolStr::new("iter"),
-                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![iter]] },
-            ),
-            (
-                SmolStr::new("hash"),
-                ModPath { kind: PathKind::Plain, segments: vec![name![std], name![hash]] },
-            ),
-            (
-                SmolStr::new("Debug"),
-                ModPath {
-                    kind: PathKind::Plain,
-                    segments: vec![name![std], name![fmt], name![Debug]],
-                },
-            ),
-            (
-                SmolStr::new("Display"),
-                ModPath {
-                    kind: PathKind::Plain,
-                    segments: vec![name![std], name![fmt], name![Display]],
-                },
-            ),
-            (
-                SmolStr::new("Hash"),
-                ModPath {
-                    kind: PathKind::Plain,
-                    segments: vec![name![std], name![hash], name![Hash]],
-                },
-            ),
-            (
-                SmolStr::new("Hasher"),
-                ModPath {
-                    kind: PathKind::Plain,
-                    segments: vec![name![std], name![hash], name![Hasher]],
-                },
-            ),
-            (
-                SmolStr::new("Iterator"),
-                ModPath {
-                    kind: PathKind::Plain,
-                    segments: vec![name![std], name![iter], name![Iterator]],
-                },
-            ),
-        ];
-        ImportResolver { dummy_names }
-    }
-    // Returns a map of importable items filtered by name.
-    // The map associates item name with its full path.
-    // todo: should return Resolutions
-    pub(crate) fn all_names(&self, name: &str) -> FxHashMap<SmolStr, ModPath> {
-        if name.len() > 1 {
-            self.dummy_names.iter().filter(|(n, _)| n.contains(name)).cloned().collect()
-        } else {
-            FxHashMap::default()
-        }
-    }
 }
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
        do_completion(code, CompletionKind::Reference)
    }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 6b0d3d996..2ae97e65f 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -80,8 +80,7 @@ fn get_inlay_hints(
            },
            ast::MatchArmList(it) => {
                it.arms()
-                    .map(|match_arm| match_arm.pats())
+                    .filter_map(|match_arm| match_arm.pat())
-                    .flatten()
                    .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, true, max_inlay_hint_length));
            },
            ast::CallExpr(it) => {
@@ -202,6 +201,7 @@ fn get_leaf_pats(root_pat: ast::Pat) -> Vec<ast::Pat> {
                Some(pat) => pats_to_process.push_back(pat),
                _ => leaf_pats.push(maybe_leaf_pat),
            },
+            ast::Pat::OrPat(ref_pat) => pats_to_process.extend(ref_pat.pats()),
            ast::Pat::TuplePat(tuple_pat) => pats_to_process.extend(tuple_pat.args()),
            ast::Pat::RecordPat(record_pat) => {
                if let Some(pat_list) = record_pat.record_field_pat_list() {
@@ -222,6 +222,7 @@ fn get_leaf_pats(root_pat: ast::Pat) -> Vec<ast::Pat> {
            ast::Pat::TupleStructPat(tuple_struct_pat) => {
                pats_to_process.extend(tuple_struct_pat.args())
            }
+            ast::Pat::ParenPat(inner_pat) => pats_to_process.extend(inner_pat.pat()),
            ast::Pat::RefPat(ref_pat) => pats_to_process.extend(ref_pat.pat()),
            _ => (),
        }
diff --git a/crates/ra_ide/src/join_lines.rs b/crates/ra_ide/src/join_lines.rs
index 7deeb3494..01fb32b3d 100644
--- a/crates/ra_ide/src/join_lines.rs
+++ b/crates/ra_ide/src/join_lines.rs
@@ -60,36 +60,15 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextU
        return;
    }
-    // Special case that turns something like:
-    //
-    // ```
-    // my_function({<|>
-    //    <some-expr>
-    // })
-    // ```
-    //
-    // into `my_function(<some-expr>)`
-    if join_single_expr_block(edit, token).is_some() {
-        return;
-    }
-    // ditto for
-    //
-    // ```
-    // use foo::{<|>
-    //    bar
-    // };
-    // ```
-    if join_single_use_tree(edit, token).is_some() {
-        return;
-    }
    // The node is between two other nodes
    let prev = token.prev_sibling_or_token().unwrap();
    let next = token.next_sibling_or_token().unwrap();
    if is_trailing_comma(prev.kind(), next.kind()) {
        // Removes: trailing comma, newline (incl. surrounding whitespace)
        edit.delete(TextRange::from_to(prev.text_range().start(), token.text_range().end()));
-    } else if prev.kind() == T![,] && next.kind() == T!['}'] {
+        return;
+    }
+    if prev.kind() == T![,] && next.kind() == T!['}'] {
        // Removes: comma, newline (incl. surrounding whitespace)
        let space = if let Some(left) = prev.prev_sibling_or_token() {
            compute_ws(left.kind(), next.kind())
@@ -100,7 +79,10 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextU
            TextRange::from_to(prev.text_range().start(), token.text_range().end()),
            space.to_string(),
        );
-    } else if let (Some(_), Some(next)) = (
+        return;
+    }
+    if let (Some(_), Some(next)) = (
        prev.as_token().cloned().and_then(ast::Comment::cast),
        next.as_token().cloned().and_then(ast::Comment::cast),
    ) {
@@ -109,10 +91,34 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextU
            token.text_range().start(),
            next.syntax().text_range().start() + TextUnit::of_str(next.prefix()),
        ));
-    } else {
+        return;
-        // Remove newline but add a computed amount of whitespace characters
+    }
-        edit.replace(token.text_range(), compute_ws(prev.kind(), next.kind()).to_string());
+    // Special case that turns something like:
+    //
+    // ```
+    // my_function({<|>
+    //    <some-expr>
+    // })
+    // ```
+    //
+    // into `my_function(<some-expr>)`
+    if join_single_expr_block(edit, token).is_some() {
+        return;
    }
+    // ditto for
+    //
+    // ```
+    // use foo::{<|>
+    //    bar
+    // };
+    // ```
+    if join_single_use_tree(edit, token).is_some() {
+        return;
+    }
+    // Remove newline but add a computed amount of whitespace characters
+    edit.replace(token.text_range(), compute_ws(prev.kind(), next.kind()).to_string());
 }
 fn has_comma_after(node: &SyntaxNode) -> bool {
@@ -608,4 +614,27 @@ pub fn handle_find_matching_brace() {
 }",
        );
    }
+    #[test]
+    fn test_join_lines_commented_block() {
+        check_join_lines(
+            r"
+fn main() {
+    let _ = {
+        // <|>foo
+        // bar
+        92
+    };
+}
+        ",
+            r"
+fn main() {
+    let _ = {
+        // <|>foo bar
+        92
+    };
+}
+        ",
+        )
+    }
 }
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index a6320bd2f..de924fad2 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -13,6 +13,7 @@ mod classify;
 mod rename;
 mod search_scope;
+use crate::expand::descend_into_macros_with_analyzer;
 use hir::{InFile, SourceBinder};
 use once_cell::unsync::Lazy;
 use ra_db::{SourceDatabase, SourceDatabaseExt};
@@ -192,39 +193,62 @@ fn process_definition(
        let parse = Lazy::new(|| SourceFile::parse(&text));
        let mut sb = Lazy::new(|| SourceBinder::new(db));
+        let mut analyzer = None;
        for (idx, _) in text.match_indices(pat) {
            let offset = TextUnit::from_usize(idx);
-            if let Some(name_ref) =
+            let (name_ref, range) = if let Some(name_ref) =
                find_node_at_offset::<ast::NameRef>(parse.tree().syntax(), offset)
            {
                let range = name_ref.syntax().text_range();
-                if let Some(search_range) = search_range {
+                (InFile::new(file_id.into(), name_ref), range)
-                    if !range.is_subrange(&search_range) {
+            } else {
-                        continue;
+                // Handle macro token cases
-                    }
+                let t = match parse.tree().syntax().token_at_offset(offset) {
+                    TokenAtOffset::None => continue,
+                    TokenAtOffset::Single(t) => t,
+                    TokenAtOffset::Between(_, t) => t,
+                };
+                let range = t.text_range();
+                let analyzer = analyzer.get_or_insert_with(|| {
+                    sb.analyze(InFile::new(file_id.into(), parse.tree().syntax()), None)
+                });
+                let expanded = descend_into_macros_with_analyzer(
+                    db,
+                    &analyzer,
+                    InFile::new(file_id.into(), t),
+                );
+                if let Some(token) = ast::NameRef::cast(expanded.value.parent()) {
+                    (expanded.with_value(token), range)
+                } else {
+                    continue;
                }
-                // FIXME: reuse sb
+            };
-                // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
+            if let Some(search_range) = search_range {
-                if let Some(d) = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
+                if !range.is_subrange(&search_range) {
-                {
+                    continue;
-                    if d == def {
+                }
-                        let kind = if is_record_lit_name_ref(&name_ref)
+            }
-                            || is_call_expr_name_ref(&name_ref)
+            // FIXME: reuse sb
-                        {
+            // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
-                            ReferenceKind::StructLiteral
-                        } else {
+            if let Some(d) = classify_name_ref(&mut sb, name_ref.as_ref()) {
-                            ReferenceKind::Other
+                if d == def {
-                        };
+                    let kind = if is_record_lit_name_ref(&name_ref.value)
+                        || is_call_expr_name_ref(&name_ref.value)
-                        refs.push(Reference {
+                    {
-                            file_range: FileRange { file_id, range },
+                        ReferenceKind::StructLiteral
-                            kind,
+                    } else {
-                            access: reference_access(&d.kind, &name_ref),
+                        ReferenceKind::Other
-                        });
+                    };
-                    }
+                    refs.push(Reference {
+                        file_range: FileRange { file_id, range },
+                        kind,
+                        access: reference_access(&d.kind, &name_ref.value),
+                    });
                }
            }
        }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 08e77c01f..c46b78cb6 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -211,6 +211,25 @@ mod tests {
    }
    #[test]
+    fn test_rename_for_macro_args() {
+        test_rename(
+            r#"
+    macro_rules! foo {($i:ident) => {$i} }
+    fn main() {
+        let a<|> = "test";
+        foo!(a);
+    }"#,
+            "b",
+            r#"
+    macro_rules! foo {($i:ident) => {$i} }
+    fn main() {
+        let b = "test";
+        foo!(b);
+    }"#,
+        );
+    }
+    #[test]
    fn test_rename_for_param_inside() {
        test_rename(
            r#"
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 1208c1343..a3464a5a3 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -31,6 +31,8 @@ mod config;
 mod world;
 mod diagnostics;
+use serde::de::DeserializeOwned;
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 pub use crate::{
    caps::server_capabilities,
@@ -38,3 +40,9 @@ pub use crate::{
    main_loop::LspError,
    main_loop::{main_loop, show_message},
 };
+pub fn from_json<T: DeserializeOwned>(what: &'static str, json: serde_json::Value) -> Result<T> {
+    let res = T::deserialize(&json)
+        .map_err(|e| format!("Failed to deserialize {}: {}; {}", what, e, json))?;
+    Ok(res)
+}
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index 3879eeff2..c8a017c5c 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -1,7 +1,7 @@
 //! `ra_lsp_server` binary
 use lsp_server::Connection;
-use ra_lsp_server::{show_message, Result, ServerConfig};
+use ra_lsp_server::{from_json, show_message, Result, ServerConfig};
 use ra_prof;
 fn main() -> Result<()> {
@@ -45,7 +45,8 @@ fn run_server() -> Result<()> {
    let server_capabilities = serde_json::to_value(ra_lsp_server::server_capabilities()).unwrap();
    let initialize_params = connection.initialize(server_capabilities)?;
-    let initialize_params: lsp_types::InitializeParams = serde_json::from_value(initialize_params)?;
+    let initialize_params =
+        from_json::<lsp_types::InitializeParams>("InitializeParams", initialize_params)?;
    if let Some(client_info) = initialize_params.client_info {
        log::info!("Client '{}' {}", client_info.name, client_info.version.unwrap_or_default());
@@ -62,17 +63,13 @@ fn run_server() -> Result<()> {
        .filter(|workspaces| !workspaces.is_empty())
        .unwrap_or_else(|| vec![root]);
-    let server_config: ServerConfig = initialize_params
+    let server_config = initialize_params
        .initialization_options
        .and_then(|v| {
-            serde_json::from_value(v)
+            from_json::<ServerConfig>("config", v)
                .map_err(|e| {
-                    log::error!("failed to deserialize config: {}", e);
+                    log::error!("{}", e);
-                    show_message(
+                    show_message(lsp_types::MessageType::Error, e.to_string(), &connection.sender);
-                        lsp_types::MessageType::Error,
-                        format!("failed to deserialize config: {}", e),
-                        &connection.sender,
-                    );
                })
                .ok()
        })
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 282f6e8fc..59c86bbfa 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -2,20 +2,21 @@
 //! The majority of requests are fulfilled by calling into the `ra_ide` crate.
 use std::{
+    collections::hash_map::Entry,
    fmt::Write as _,
    io::Write as _,
    process::{self, Stdio},
 };
-use either::Either;
 use lsp_server::ErrorCode;
 use lsp_types::{
    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
    CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
-    CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
+    CodeAction, CodeActionOrCommand, CodeActionResponse, CodeLens, Command, CompletionItem,
-    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeParams,
+    Diagnostic, DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
-    Hover, HoverContents, Location, MarkupContent, MarkupKind, Position, PrepareRenameResponse,
+    FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind, Position,
-    Range, RenameParams, SymbolInformation, TextDocumentIdentifier, TextEdit, WorkspaceEdit,
+    PrepareRenameResponse, Range, RenameParams, SymbolInformation, TextDocumentIdentifier,
+    TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
    AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
@@ -34,6 +35,7 @@ use crate::{
        TryConvWithToVec,
    },
    diagnostics::DiagnosticTask,
+    from_json,
    req::{self, Decoration, InlayHint, InlayHintsParams, InlayKind},
    world::WorldSnapshot,
    LspError, Result,
@@ -685,34 +687,53 @@ pub fn handle_code_action(
        res.push(fix.action.clone());
    }
+    let mut groups = FxHashMap::default();
    for assist in world.analysis().assists(FileRange { file_id, range })?.into_iter() {
-        let title = assist.label.clone();
+        let arg = to_value(assist.source_change.try_conv_with(&world)?)?;
+        let (command, title, arg) = match assist.group_label {
+            None => ("rust-analyzer.applySourceChange", assist.label.clone(), arg),
+            // Group all assists with the same `group_label` into a single CodeAction.
+            Some(group_label) => {
+                match groups.entry(group_label.clone()) {
+                    Entry::Occupied(entry) => {
+                        let idx: usize = *entry.get();
+                        match &mut res[idx] {
+                            CodeActionOrCommand::CodeAction(CodeAction {
+                                command: Some(Command { arguments: Some(arguments), .. }),
+                                ..
+                            }) => match arguments.as_mut_slice() {
+                                [serde_json::Value::Array(arguments)] => arguments.push(arg),
+                                _ => panic!("invalid group"),
+                            },
+                            _ => panic!("invalid group"),
+                        }
+                        continue;
+                    }
+                    Entry::Vacant(entry) => {
+                        entry.insert(res.len());
+                    }
+                }
+                ("rust-analyzer.selectAndApplySourceChange", group_label, to_value(vec![arg])?)
+            }
+        };
-        let command = match assist.change_data {
+        let command = Command {
-            Either::Left(change) => Command {
+            title: assist.label.clone(),
-                title,
+            command: command.to_string(),
-                command: "rust-analyzer.applySourceChange".to_string(),
+            arguments: Some(vec![arg]),
-                arguments: Some(vec![to_value(change.try_conv_with(&world)?)?]),
+        };
-            },
-            Either::Right(changes) => Command {
+        let kind = match assist.id {
-                title,
+            AssistId("introduce_variable") => Some("refactor.extract.variable".to_string()),
-                command: "rust-analyzer.selectAndApplySourceChange".to_string(),
+            AssistId("add_custom_impl") => Some("refactor.rewrite.add_custom_impl".to_string()),
-                arguments: Some(vec![to_value(
+            _ => None,
-                    changes
-                        .into_iter()
-                        .map(|change| change.try_conv_with(&world))
-                        .collect::<Result<Vec<_>>>()?,
-                )?]),
-            },
        };
        let action = CodeAction {
-            title: command.title.clone(),
+            title,
-            kind: match assist.id {
+            kind,
-                AssistId("introduce_variable") => Some("refactor.extract.variable".to_string()),
-                AssistId("add_custom_impl") => Some("refactor.rewrite.add_custom_impl".to_string()),
-                _ => None,
-            },
            diagnostics: None,
            edit: None,
            command: Some(command),
@@ -791,7 +812,7 @@ enum CodeLensResolveData {
 pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> {
    let _p = profile("handle_code_lens_resolve");
    let data = code_lens.data.unwrap();
-    let resolve = serde_json::from_value(data)?;
+    let resolve = from_json::<Option<CodeLensResolveData>>("CodeLensResolveData", data)?;
    match resolve {
        Some(CodeLensResolveData::Impls(lens_params)) => {
            let locations: Vec<Location> =
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index f154077a8..b72d2e9e6 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -336,7 +336,7 @@ fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 fn cond(p: &mut Parser) {
    let m = p.start();
    if p.eat(T![let]) {
-        patterns::pattern_list(p);
+        patterns::pattern_top(p);
        p.expect(T![=]);
    }
    expr_no_struct(p);
@@ -430,7 +430,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
    // }
    attributes::outer_attributes(p);
-    patterns::pattern_list_r(p, TokenSet::EMPTY);
+    patterns::pattern_top_r(p, TokenSet::EMPTY);
    if p.at(T![if]) {
        match_guard(p);
    }
diff --git a/crates/ra_parser/src/grammar/params.rs b/crates/ra_parser/src/grammar/params.rs
index 94edc7f35..ed4f93347 100644
--- a/crates/ra_parser/src/grammar/params.rs
+++ b/crates/ra_parser/src/grammar/params.rs
@@ -116,7 +116,7 @@ fn value_parameter(p: &mut Parser, flavor: Flavor) {
        // type Qux = fn(baz: Bar::Baz);
        Flavor::FnPointer => {
            if p.at(IDENT) && p.nth(1) == T![:] && !p.nth_at(1, T![::]) {
-                patterns::pattern(p);
+                patterns::pattern_single(p);
                types::ascription(p);
            } else {
                types::type_(p);
@@ -127,7 +127,7 @@ fn value_parameter(p: &mut Parser, flavor: Flavor) {
        //    let foo = |bar, baz: Baz, qux: Qux::Quux| ();
        // }
        Flavor::Closure => {
-            patterns::pattern(p);
+            patterns::pattern_single(p);
            if p.at(T![:]) && !p.at(T![::]) {
                types::ascription(p);
            }
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index 422a4e3dc..3afbaa82b 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -11,22 +11,47 @@ pub(crate) fn pattern(p: &mut Parser) {
 }
 /// Parses a pattern list separated by pipes `|`
-pub(super) fn pattern_list(p: &mut Parser) {
+pub(super) fn pattern_top(p: &mut Parser) {
-    pattern_list_r(p, PAT_RECOVERY_SET)
+    pattern_top_r(p, PAT_RECOVERY_SET)
+}
+pub(crate) fn pattern_single(p: &mut Parser) {
+    pattern_single_r(p, PAT_RECOVERY_SET);
 }
 /// Parses a pattern list separated by pipes `|`
 /// using the given `recovery_set`
-pub(super) fn pattern_list_r(p: &mut Parser, recovery_set: TokenSet) {
+pub(super) fn pattern_top_r(p: &mut Parser, recovery_set: TokenSet) {
    p.eat(T![|]);
    pattern_r(p, recovery_set);
+}
+/// Parses a pattern list separated by pipes `|`, with no leading `|`,using the
+/// given `recovery_set`
+// test or_pattern
+// fn main() {
+//     match () {
+//         (_ | _) => (),
+//         &(_ | _) => (),
+//         (_ | _,) => (),
+//         [_ | _,] => (),
+//     }
+// }
+fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
+    let m = p.start();
+    pattern_single_r(p, recovery_set);
+    if !p.at(T![|]) {
+        m.abandon(p);
+        return;
+    }
    while p.eat(T![|]) {
-        pattern_r(p, recovery_set);
+        pattern_single_r(p, recovery_set);
    }
+    m.complete(p, OR_PAT);
 }
-pub(super) fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
+fn pattern_single_r(p: &mut Parser, recovery_set: TokenSet) {
    if let Some(lhs) = atom_pat(p, recovery_set) {
        // test range_pat
        // fn main() {
@@ -258,19 +283,41 @@ fn ref_pat(p: &mut Parser) -> CompletedMarker {
    let m = p.start();
    p.bump(T![&]);
    p.eat(T![mut]);
-    pattern(p);
+    pattern_single(p);
    m.complete(p, REF_PAT)
 }
 // test tuple_pat
 // fn main() {
 //     let (a, b, ..) = ();
+//     let (a,) = ();
+//     let (..) = ();
+//     let () = ();
 // }
 fn tuple_pat(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T!['(']));
    let m = p.start();
-    tuple_pat_fields(p);
+    p.bump(T!['(']);
-    m.complete(p, TUPLE_PAT)
+    let mut has_comma = false;
+    let mut has_pat = false;
+    let mut has_rest = false;
+    while !p.at(EOF) && !p.at(T![')']) {
+        has_pat = true;
+        if !p.at_ts(PATTERN_FIRST) {
+            p.error("expected a pattern");
+            break;
+        }
+        has_rest |= p.at(T![..]);
+        pattern(p);
+        if !p.at(T![')']) {
+            has_comma = true;
+            p.expect(T![,]);
+        }
+    }
+    p.expect(T![')']);
+    m.complete(p, if !has_comma && !has_rest && has_pat { PAREN_PAT } else { TUPLE_PAT })
 }
 // test slice_pat
@@ -315,7 +362,7 @@ fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
    p.eat(T![mut]);
    name(p);
    if with_at && p.eat(T![@]) {
-        pattern(p);
+        pattern_single(p);
    }
    m.complete(p, BIND_PAT)
 }
@@ -330,6 +377,6 @@ fn box_pat(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![box]));
    let m = p.start();
    p.bump(T![box]);
-    pattern(p);
+    pattern_single(p);
    m.complete(p, BOX_PAT)
 }
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index 4b301d67a..1068da0a0 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 #![allow(bad_style, missing_docs, unreachable_pub)]
 #[doc = r" The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`."]
@@ -151,6 +151,8 @@ pub enum SyntaxKind {
    FOR_TYPE,
    IMPL_TRAIT_TYPE,
    DYN_TRAIT_TYPE,
+    OR_PAT,
+    PAREN_PAT,
    REF_PAT,
    BOX_PAT,
    BIND_PAT,
diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs
index 34d066b1e..a23265fc0 100644
--- a/crates/ra_project_model/src/sysroot.rs
+++ b/crates/ra_project_model/src/sysroot.rs
@@ -99,7 +99,8 @@ fn try_find_src_path(cargo_toml: &Path) -> Result<PathBuf> {
    let rustc_output = Command::new("rustc")
        .current_dir(cargo_toml.parent().unwrap())
        .args(&["--print", "sysroot"])
-        .output()?;
+        .output()
+        .map_err(|e| format!("rustc --print sysroot failed: {}", e))?;
    if !rustc_output.status.success() {
        Err("failed to locate sysroot")?;
    }
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index c5a3d1999..83db943fe 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -4,7 +4,7 @@ name = "ra_syntax"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 license = "MIT OR Apache-2.0"
-description = "Comment and whitespace preserving parser for the Rust langauge"
+description = "Comment and whitespace preserving parser for the Rust language"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 [lib]
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 8a3669bd1..8eb240801 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,4 +1,4 @@
-//! Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`
+//! Generated file, do not edit by hand, see `xtask/src/codegen`
 use crate::{
    ast::{self, AstChildren, AstNode},
@@ -1759,8 +1759,8 @@ impl AstNode for MatchArm {
 }
 impl ast::AttrsOwner for MatchArm {}
 impl MatchArm {
-    pub fn pats(&self) -> AstChildren<Pat> {
+    pub fn pat(&self) -> Option<Pat> {
-        AstChildren::new(&self.syntax)
+        AstChildren::new(&self.syntax).next()
    }
    pub fn guard(&self) -> Option<MatchGuard> {
        AstChildren::new(&self.syntax).next()
@@ -1887,6 +1887,60 @@ impl RecordField {
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct OrPat {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for OrPat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            OR_PAT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl OrPat {
+    pub fn pats(&self) -> AstChildren<Pat> {
+        AstChildren::new(&self.syntax)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParenPat {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for ParenPat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            PAREN_PAT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl ParenPat {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefPat {
    pub(crate) syntax: SyntaxNode,
 }
@@ -3904,6 +3958,8 @@ impl AstNode for Expr {
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Pat {
+    OrPat(OrPat),
+    ParenPat(ParenPat),
    RefPat(RefPat),
    BoxPat(BoxPat),
    BindPat(BindPat),
@@ -3917,6 +3973,16 @@ pub enum Pat {
    RangePat(RangePat),
    LiteralPat(LiteralPat),
 }
+impl From<OrPat> for Pat {
+    fn from(node: OrPat) -> Pat {
+        Pat::OrPat(node)
+    }
+}
+impl From<ParenPat> for Pat {
+    fn from(node: ParenPat) -> Pat {
+        Pat::ParenPat(node)
+    }
+}
 impl From<RefPat> for Pat {
    fn from(node: RefPat) -> Pat {
        Pat::RefPat(node)
@@ -3980,15 +4046,16 @@ impl From<LiteralPat> for Pat {
 impl AstNode for Pat {
    fn can_cast(kind: SyntaxKind) -> bool {
        match kind {
-            REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT | PATH_PAT
+            OR_PAT | PAREN_PAT | REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT
-            | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT | LITERAL_PAT => {
+            | PATH_PAT | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT
-                true
+            | LITERAL_PAT => true,
-            }
            _ => false,
        }
    }
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
+            OR_PAT => Pat::OrPat(OrPat { syntax }),
+            PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
            REF_PAT => Pat::RefPat(RefPat { syntax }),
            BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
            BIND_PAT => Pat::BindPat(BindPat { syntax }),
@@ -4007,6 +4074,8 @@ impl AstNode for Pat {
    }
    fn syntax(&self) -> &SyntaxNode {
        match self {
+            Pat::OrPat(it) => &it.syntax,
+            Pat::ParenPat(it) => &it.syntax,
            Pat::RefPat(it) => &it.syntax,
            Pat::BoxPat(it) => &it.syntax,
            Pat::BindPat(it) => &it.syntax,
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.txt b/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.txt
index 4028ca243..6fd49c7bc 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0030_cond.txt
@@ -63,27 +63,28 @@ SOURCE_FILE@[0; 197)
            CONDITION@[56; 84)
              LET_KW@[56; 59) "let"
              WHITESPACE@[59; 60) " "
-              TUPLE_STRUCT_PAT@[60; 67)
+              OR_PAT@[60; 77)
-                PATH@[60; 64)
+                TUPLE_STRUCT_PAT@[60; 67)
-                  PATH_SEGMENT@[60; 64)
+                  PATH@[60; 64)
-                    NAME_REF@[60; 64)
+                    PATH_SEGMENT@[60; 64)
-                      IDENT@[60; 64) "Some"
+                      NAME_REF@[60; 64)
-                L_PAREN@[64; 65) "("
+                        IDENT@[60; 64) "Some"
-                PLACEHOLDER_PAT@[65; 66)
+                  L_PAREN@[64; 65) "("
-                  UNDERSCORE@[65; 66) "_"
+                  PLACEHOLDER_PAT@[65; 66)
-                R_PAREN@[66; 67) ")"
+                    UNDERSCORE@[65; 66) "_"
-              WHITESPACE@[67; 68) " "
+                  R_PAREN@[66; 67) ")"
-              PIPE@[68; 69) "|"
+                WHITESPACE@[67; 68) " "
-              WHITESPACE@[69; 70) " "
+                PIPE@[68; 69) "|"
-              TUPLE_STRUCT_PAT@[70; 77)
+                WHITESPACE@[69; 70) " "
-                PATH@[70; 74)
+                TUPLE_STRUCT_PAT@[70; 77)
-                  PATH_SEGMENT@[70; 74)
+                  PATH@[70; 74)
-                    NAME_REF@[70; 74)
+                    PATH_SEGMENT@[70; 74)
-                      IDENT@[70; 74) "Some"
+                      NAME_REF@[70; 74)
-                L_PAREN@[74; 75) "("
+                        IDENT@[70; 74) "Some"
-                PLACEHOLDER_PAT@[75; 76)
+                  L_PAREN@[74; 75) "("
-                  UNDERSCORE@[75; 76) "_"
+                  PLACEHOLDER_PAT@[75; 76)
-                R_PAREN@[76; 77) ")"
+                    UNDERSCORE@[75; 76) "_"
+                  R_PAREN@[76; 77) ")"
              WHITESPACE@[77; 78) " "
              EQ@[78; 79) "="
              WHITESPACE@[79; 80) " "
@@ -137,27 +138,28 @@ SOURCE_FILE@[0; 197)
            CONDITION@[129; 157)
              LET_KW@[129; 132) "let"
              WHITESPACE@[132; 133) " "
-              TUPLE_STRUCT_PAT@[133; 140)
+              OR_PAT@[133; 150)
-                PATH@[133; 137)
+                TUPLE_STRUCT_PAT@[133; 140)
-                  PATH_SEGMENT@[133; 137)
+                  PATH@[133; 137)
-                    NAME_REF@[133; 137)
+                    PATH_SEGMENT@[133; 137)
-                      IDENT@[133; 137) "Some"
+                      NAME_REF@[133; 137)
-                L_PAREN@[137; 138) "("
+                        IDENT@[133; 137) "Some"
-                PLACEHOLDER_PAT@[138; 139)
+                  L_PAREN@[137; 138) "("
-                  UNDERSCORE@[138; 139) "_"
+                  PLACEHOLDER_PAT@[138; 139)
-                R_PAREN@[139; 140) ")"
+                    UNDERSCORE@[138; 139) "_"
-              WHITESPACE@[140; 141) " "
+                  R_PAREN@[139; 140) ")"
-              PIPE@[141; 142) "|"
+                WHITESPACE@[140; 141) " "
-              WHITESPACE@[142; 143) " "
+                PIPE@[141; 142) "|"
-              TUPLE_STRUCT_PAT@[143; 150)
+                WHITESPACE@[142; 143) " "
-                PATH@[143; 147)
+                TUPLE_STRUCT_PAT@[143; 150)
-                  PATH_SEGMENT@[143; 147)
+                  PATH@[143; 147)
-                    NAME_REF@[143; 147)
+                    PATH_SEGMENT@[143; 147)
-                      IDENT@[143; 147) "Some"
+                      NAME_REF@[143; 147)
-                L_PAREN@[147; 148) "("
+                        IDENT@[143; 147) "Some"
-                PLACEHOLDER_PAT@[148; 149)
+                  L_PAREN@[147; 148) "("
-                  UNDERSCORE@[148; 149) "_"
+                  PLACEHOLDER_PAT@[148; 149)
-                R_PAREN@[149; 150) ")"
+                    UNDERSCORE@[148; 149) "_"
+                  R_PAREN@[149; 150) ")"
              WHITESPACE@[150; 151) " "
              EQ@[151; 152) "="
              WHITESPACE@[152; 153) " "
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.txt b/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.txt
index 87272917b..2f07af4e1 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0066_match_arm.txt
@@ -74,15 +74,16 @@ SOURCE_FILE@[0; 167)
              COMMA@[83; 84) ","
              WHITESPACE@[84; 93) "\n        "
              MATCH_ARM@[93; 109)
-                BIND_PAT@[93; 94)
+                OR_PAT@[93; 98)
-                  NAME@[93; 94)
+                  BIND_PAT@[93; 94)
-                    IDENT@[93; 94) "X"
+                    NAME@[93; 94)
-                WHITESPACE@[94; 95) " "
+                      IDENT@[93; 94) "X"
-                PIPE@[95; 96) "|"
+                  WHITESPACE@[94; 95) " "
-                WHITESPACE@[96; 97) " "
+                  PIPE@[95; 96) "|"
-                BIND_PAT@[97; 98)
+                  WHITESPACE@[96; 97) " "
-                  NAME@[97; 98)
+                  BIND_PAT@[97; 98)
-                    IDENT@[97; 98) "Y"
+                    NAME@[97; 98)
+                      IDENT@[97; 98) "Y"
                WHITESPACE@[98; 99) " "
                MATCH_GUARD@[99; 103)
                  IF_KW@[99; 101) "if"
@@ -103,15 +104,16 @@ SOURCE_FILE@[0; 167)
              MATCH_ARM@[119; 137)
                PIPE@[119; 120) "|"
                WHITESPACE@[120; 121) " "
-                BIND_PAT@[121; 122)
+                OR_PAT@[121; 126)
-                  NAME@[121; 122)
+                  BIND_PAT@[121; 122)
-                    IDENT@[121; 122) "X"
+                    NAME@[121; 122)
-                WHITESPACE@[122; 123) " "
+                      IDENT@[121; 122) "X"
-                PIPE@[123; 124) "|"
+                  WHITESPACE@[122; 123) " "
-                WHITESPACE@[124; 125) " "
+                  PIPE@[123; 124) "|"
-                BIND_PAT@[125; 126)
+                  WHITESPACE@[124; 125) " "
-                  NAME@[125; 126)
+                  BIND_PAT@[125; 126)
-                    IDENT@[125; 126) "Y"
+                    NAME@[125; 126)
+                      IDENT@[125; 126) "Y"
                WHITESPACE@[126; 127) " "
                MATCH_GUARD@[127; 131)
                  IF_KW@[127; 129) "if"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rs b/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rs
index f785acd36..ba719879d 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rs
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.rs
@@ -1,3 +1,6 @@
 fn main() {
    let (a, b, ..) = ();
+    let (a,) = ();
+    let (..) = ();
+    let () = ();
 }
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.txt b/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.txt
index 674dec493..4680c267e 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0111_tuple_pat.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 39)
+SOURCE_FILE@[0; 94)
-  FN_DEF@[0; 38)
+  FN_DEF@[0; 93)
    FN_KW@[0; 2) "fn"
    WHITESPACE@[2; 3) " "
    NAME@[3; 7)
@@ -8,8 +8,8 @@ SOURCE_FILE@[0; 39)
      L_PAREN@[7; 8) "("
      R_PAREN@[8; 9) ")"
    WHITESPACE@[9; 10) " "
-    BLOCK_EXPR@[10; 38)
+    BLOCK_EXPR@[10; 93)
-      BLOCK@[10; 38)
+      BLOCK@[10; 93)
        L_CURLY@[10; 11) "{"
        WHITESPACE@[11; 16) "\n    "
        LET_STMT@[16; 36)
@@ -37,6 +37,54 @@ SOURCE_FILE@[0; 39)
            L_PAREN@[33; 34) "("
            R_PAREN@[34; 35) ")"
          SEMI@[35; 36) ";"
-        WHITESPACE@[36; 37) "\n"
+        WHITESPACE@[36; 41) "\n    "
-        R_CURLY@[37; 38) "}"
+        LET_STMT@[41; 55)
-  WHITESPACE@[38; 39) "\n"
+          LET_KW@[41; 44) "let"
+          WHITESPACE@[44; 45) " "
+          TUPLE_PAT@[45; 49)
+            L_PAREN@[45; 46) "("
+            BIND_PAT@[46; 47)
+              NAME@[46; 47)
+                IDENT@[46; 47) "a"
+            COMMA@[47; 48) ","
+            R_PAREN@[48; 49) ")"
+          WHITESPACE@[49; 50) " "
+          EQ@[50; 51) "="
+          WHITESPACE@[51; 52) " "
+          TUPLE_EXPR@[52; 54)
+            L_PAREN@[52; 53) "("
+            R_PAREN@[53; 54) ")"
+          SEMI@[54; 55) ";"
+        WHITESPACE@[55; 60) "\n    "
+        LET_STMT@[60; 74)
+          LET_KW@[60; 63) "let"
+          WHITESPACE@[63; 64) " "
+          TUPLE_PAT@[64; 68)
+            L_PAREN@[64; 65) "("
+            DOT_DOT_PAT@[65; 67)
+              DOTDOT@[65; 67) ".."
+            R_PAREN@[67; 68) ")"
+          WHITESPACE@[68; 69) " "
+          EQ@[69; 70) "="
+          WHITESPACE@[70; 71) " "
+          TUPLE_EXPR@[71; 73)
+            L_PAREN@[71; 72) "("
+            R_PAREN@[72; 73) ")"
+          SEMI@[73; 74) ";"
+        WHITESPACE@[74; 79) "\n    "
+        LET_STMT@[79; 91)
+          LET_KW@[79; 82) "let"
+          WHITESPACE@[82; 83) " "
+          TUPLE_PAT@[83; 85)
+            L_PAREN@[83; 84) "("
+            R_PAREN@[84; 85) ")"
+          WHITESPACE@[85; 86) " "
+          EQ@[86; 87) "="
+          WHITESPACE@[87; 88) " "
+          TUPLE_EXPR@[88; 90)
+            L_PAREN@[88; 89) "("
+            R_PAREN@[89; 90) ")"
+          SEMI@[90; 91) ";"
+        WHITESPACE@[91; 92) "\n"
+        R_CURLY@[92; 93) "}"
+  WHITESPACE@[93; 94) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rs b/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rs
new file mode 100644
index 000000000..a26316605
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.rs
@@ -0,0 +1,8 @@
+fn main() {
+    match () {
+        (_ | _) => (),
+        &(_ | _) => (),
+        (_ | _,) => (),
+        [_ | _,] => (),
+    }
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.txt b/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.txt
new file mode 100644
index 000000000..3a196d3c0
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0156_or_pattern.txt
@@ -0,0 +1,112 @@
+SOURCE_FILE@[0; 130)
+  FN_DEF@[0; 129)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 129)
+      BLOCK@[10; 129)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        MATCH_EXPR@[16; 127)
+          MATCH_KW@[16; 21) "match"
+          WHITESPACE@[21; 22) " "
+          TUPLE_EXPR@[22; 24)
+            L_PAREN@[22; 23) "("
+            R_PAREN@[23; 24) ")"
+          WHITESPACE@[24; 25) " "
+          MATCH_ARM_LIST@[25; 127)
+            L_CURLY@[25; 26) "{"
+            WHITESPACE@[26; 35) "\n        "
+            MATCH_ARM@[35; 48)
+              PAREN_PAT@[35; 42)
+                L_PAREN@[35; 36) "("
+                OR_PAT@[36; 41)
+                  PLACEHOLDER_PAT@[36; 37)
+                    UNDERSCORE@[36; 37) "_"
+                  WHITESPACE@[37; 38) " "
+                  PIPE@[38; 39) "|"
+                  WHITESPACE@[39; 40) " "
+                  PLACEHOLDER_PAT@[40; 41)
+                    UNDERSCORE@[40; 41) "_"
+                R_PAREN@[41; 42) ")"
+              WHITESPACE@[42; 43) " "
+              FAT_ARROW@[43; 45) "=>"
+              WHITESPACE@[45; 46) " "
+              TUPLE_EXPR@[46; 48)
+                L_PAREN@[46; 47) "("
+                R_PAREN@[47; 48) ")"
+            COMMA@[48; 49) ","
+            WHITESPACE@[49; 58) "\n        "
+            MATCH_ARM@[58; 72)
+              REF_PAT@[58; 66)
+                AMP@[58; 59) "&"
+                PAREN_PAT@[59; 66)
+                  L_PAREN@[59; 60) "("
+                  OR_PAT@[60; 65)
+                    PLACEHOLDER_PAT@[60; 61)
+                      UNDERSCORE@[60; 61) "_"
+                    WHITESPACE@[61; 62) " "
+                    PIPE@[62; 63) "|"
+                    WHITESPACE@[63; 64) " "
+                    PLACEHOLDER_PAT@[64; 65)
+                      UNDERSCORE@[64; 65) "_"
+                  R_PAREN@[65; 66) ")"
+              WHITESPACE@[66; 67) " "
+              FAT_ARROW@[67; 69) "=>"
+              WHITESPACE@[69; 70) " "
+              TUPLE_EXPR@[70; 72)
+                L_PAREN@[70; 71) "("
+                R_PAREN@[71; 72) ")"
+            COMMA@[72; 73) ","
+            WHITESPACE@[73; 82) "\n        "
+            MATCH_ARM@[82; 96)
+              TUPLE_PAT@[82; 90)
+                L_PAREN@[82; 83) "("
+                OR_PAT@[83; 88)
+                  PLACEHOLDER_PAT@[83; 84)
+                    UNDERSCORE@[83; 84) "_"
+                  WHITESPACE@[84; 85) " "
+                  PIPE@[85; 86) "|"
+                  WHITESPACE@[86; 87) " "
+                  PLACEHOLDER_PAT@[87; 88)
+                    UNDERSCORE@[87; 88) "_"
+                COMMA@[88; 89) ","
+                R_PAREN@[89; 90) ")"
+              WHITESPACE@[90; 91) " "
+              FAT_ARROW@[91; 93) "=>"
+              WHITESPACE@[93; 94) " "
+              TUPLE_EXPR@[94; 96)
+                L_PAREN@[94; 95) "("
+                R_PAREN@[95; 96) ")"
+            COMMA@[96; 97) ","
+            WHITESPACE@[97; 106) "\n        "
+            MATCH_ARM@[106; 120)
+              SLICE_PAT@[106; 114)
+                L_BRACK@[106; 107) "["
+                OR_PAT@[107; 112)
+                  PLACEHOLDER_PAT@[107; 108)
+                    UNDERSCORE@[107; 108) "_"
+                  WHITESPACE@[108; 109) " "
+                  PIPE@[109; 110) "|"
+                  WHITESPACE@[110; 111) " "
+                  PLACEHOLDER_PAT@[111; 112)
+                    UNDERSCORE@[111; 112) "_"
+                COMMA@[112; 113) ","
+                R_BRACK@[113; 114) "]"
+              WHITESPACE@[114; 115) " "
+              FAT_ARROW@[115; 117) "=>"
+              WHITESPACE@[117; 118) " "
+              TUPLE_EXPR@[118; 120)
+                L_PAREN@[118; 119) "("
+                R_PAREN@[119; 120) ")"
+            COMMA@[120; 121) ","
+            WHITESPACE@[121; 126) "\n    "
+            R_CURLY@[126; 127) "}"
+        WHITESPACE@[127; 128) "\n"
+        R_CURLY@[128; 129) "}"
+  WHITESPACE@[129; 130) "\n"
diff --git a/crates/ra_text_edit/src/lib.rs b/crates/ra_text_edit/src/lib.rs
index 5f1b12222..37f23d043 100644
--- a/crates/ra_text_edit/src/lib.rs
+++ b/crates/ra_text_edit/src/lib.rs
@@ -29,8 +29,8 @@ impl AtomTextEdit {
    }
    pub fn apply(&self, mut text: String) -> String {
-        let start = u32::from(self.delete.start()) as usize;
+        let start = self.delete.start().to_usize();
-        let end = u32::from(self.delete.end()) as usize;
+        let end = self.delete.end().to_usize();
        text.replace_range(start..end, &self.insert);
        text
    }
diff --git a/crates/ra_text_edit/src/text_edit.rs b/crates/ra_text_edit/src/text_edit.rs
index 413c7d782..3291ada42 100644
--- a/crates/ra_text_edit/src/text_edit.rs
+++ b/crates/ra_text_edit/src/text_edit.rs
@@ -66,13 +66,13 @@ impl TextEdit {
        let mut total_len = text.len();
        for atom in self.atoms.iter() {
            total_len += atom.insert.len();
-            total_len -= u32::from(atom.delete.end() - atom.delete.start()) as usize;
+            total_len -= (atom.delete.end() - atom.delete.start()).to_usize();
        }
        let mut buf = String::with_capacity(total_len);
        let mut prev = 0;
        for atom in self.atoms.iter() {
-            let start = u32::from(atom.delete.start()) as usize;
+            let start = atom.delete.start().to_usize();
-            let end = u32::from(atom.delete.end()) as usize;
+            let end = atom.delete.end().to_usize();
            if start > prev {
                buf.push_str(&text[prev..start]);
            }