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<|>;