65 files changed, 474 insertions, 382 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index cad6866aa..8d4641355 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -197,7 +197,7 @@ impl ChangeFixture {
            change.change_file(file_id, Some(Arc::new(text)));
            let path = VfsPath::new_virtual_path(meta.path);
-            file_set.insert(file_id, path.into());
+            file_set.insert(file_id, path);
            files.push(file_id);
            file_id.0 += 1;
        }
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index 505fc05e7..dab8da7bb 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -125,5 +125,5 @@ fn resolve_doc_path(
        Some(Namespace::Macros) => return None,
        None => resolved.iter_items().find_map(|it| it.as_module_def_id())?,
    };
-    Some(def.into())
+    Some(def)
 }
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index 44cdcc296..9f6d7be48 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -12,8 +12,8 @@ use hir_ty::display::{
 use syntax::ast::{self, NameOwner};
 use crate::{
-    Const, ConstParam, Enum, Field, Function, HasVisibility, Module, Static, Struct, Substs, Trait,
+    Adt, Const, ConstParam, Enum, Field, Function, GenericParam, HasVisibility, LifetimeParam,
-    Type, TypeAlias, TypeParam, Union, Variant,
+    Module, Static, Struct, Substitution, Trait, Type, TypeAlias, TypeParam, Union, Variant,
 };
 impl HirDisplay for Function {
@@ -120,6 +120,16 @@ impl HirDisplay for Function {
    }
 }
+impl HirDisplay for Adt {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            Adt::Struct(it) => it.hir_fmt(f),
+            Adt::Union(it) => it.hir_fmt(f),
+            Adt::Enum(it) => it.hir_fmt(f),
+        }
+    }
+}
 impl HirDisplay for Struct {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
@@ -211,11 +221,21 @@ impl HirDisplay for Type {
    }
 }
+impl HirDisplay for GenericParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            GenericParam::TypeParam(it) => it.hir_fmt(f),
+            GenericParam::LifetimeParam(it) => it.hir_fmt(f),
+            GenericParam::ConstParam(it) => it.hir_fmt(f),
+        }
+    }
+}
 impl HirDisplay for TypeParam {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        write!(f, "{}", self.name(f.db))?;
        let bounds = f.db.generic_predicates_for_param(self.id);
-        let substs = Substs::type_params(f.db, self.id.parent);
+        let substs = Substitution::type_params(f.db, self.id.parent);
        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
        if !(predicates.is_empty() || f.omit_verbose_types()) {
            write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;
@@ -224,6 +244,12 @@ impl HirDisplay for TypeParam {
    }
 }
+impl HirDisplay for LifetimeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))
+    }
+}
 impl HirDisplay for ConstParam {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        write!(f, "const {}: ", self.name(f.db))?;
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 265a084f3..b41a36a78 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -57,8 +57,8 @@ use hir_ty::{
    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
    AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
-    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, Ty,
+    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substitution,
-    TyDefId, TyKind, TyVariableKind,
+    Ty, TyDefId, TyKind, TyVariableKind,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -518,7 +518,7 @@ impl Field {
            VariantDef::Union(it) => it.id.into(),
            VariantDef::Variant(it) => it.parent.id.into(),
        };
-        let substs = Substs::type_params(db, generic_def_id);
+        let substs = Substitution::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(), var_id, ty)
    }
@@ -1335,7 +1335,7 @@ impl Local {
    // FIXME: why is this an option? It shouldn't be?
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
-        let body = db.body(self.parent.into());
+        let body = db.body(self.parent);
        match &body[self.pat_id] {
            Pat::Bind { name, .. } => Some(name.clone()),
            _ => None,
@@ -1347,7 +1347,7 @@ impl Local {
    }
    pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
-        let body = db.body(self.parent.into());
+        let body = db.body(self.parent);
        matches!(&body[self.pat_id], Pat::Bind { mode: BindingAnnotation::Mutable, .. })
    }
@@ -1360,7 +1360,7 @@ impl Local {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        let def = DefWithBodyId::from(self.parent);
+        let def = self.parent;
        let infer = db.infer(def);
        let ty = infer[self.pat_id].clone();
        let krate = def.module(db.upcast()).krate();
@@ -1368,7 +1368,7 @@ impl Local {
    }
    pub fn source(self, db: &dyn HirDatabase) -> InFile<Either<ast::IdentPat, ast::SelfParam>> {
-        let (_body, source_map) = db.body_with_source_map(self.parent.into());
+        let (_body, source_map) = db.body_with_source_map(self.parent);
        let src = source_map.pat_syntax(self.pat_id).unwrap(); // Hmm...
        let root = src.file_syntax(db.upcast());
        src.map(|ast| {
@@ -1393,12 +1393,12 @@ impl Label {
    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
-        let body = db.body(self.parent.into());
+        let body = db.body(self.parent);
        body[self.label_id].name.clone()
    }
    pub fn source(self, db: &dyn HirDatabase) -> InFile<ast::Label> {
-        let (_body, source_map) = db.body_with_source_map(self.parent.into());
+        let (_body, source_map) = db.body_with_source_map(self.parent);
        let src = source_map.label_syntax(self.label_id);
        let root = src.file_syntax(db.upcast());
        src.map(|ast| ast.to_node(&root))
@@ -1471,7 +1471,7 @@ impl TypeParam {
        let resolver = self.id.parent.resolver(db.upcast());
        let krate = self.id.parent.module(db.upcast()).krate();
        let ty = params.get(local_idx)?.clone();
-        let subst = Substs::type_params(db, self.id.parent);
+        let subst = Substitution::type_params(db, self.id.parent);
        let ty = ty.subst(&subst.prefix(local_idx));
        Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
    }
@@ -1674,7 +1674,7 @@ impl Type {
        krate: CrateId,
        def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
    ) -> Type {
-        let substs = Substs::build_for_def(db, def).fill_with_unknown().build();
+        let substs = Substitution::build_for_def(db, def).fill_with_unknown().build();
        let ty = db.ty(def.into()).subst(&substs);
        Type::new(db, krate, def, ty)
    }
@@ -1754,7 +1754,7 @@ impl Type {
    pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
        let trait_ref = hir_ty::TraitRef {
            trait_: trait_.id,
-            substs: Substs::build_for_def(db, trait_.id)
+            substs: Substitution::build_for_def(db, trait_.id)
                .push(self.ty.value.clone())
                .fill(args.iter().map(|t| t.ty.value.clone()))
                .build(),
@@ -1778,7 +1778,7 @@ impl Type {
        args: &[Type],
        alias: TypeAlias,
    ) -> Option<Type> {
-        let subst = Substs::build_for_def(db, trait_.id)
+        let subst = Substitution::build_for_def(db, trait_.id)
            .push(self.ty.value.clone())
            .fill(args.iter().map(|t| t.ty.value.clone()))
            .build();
@@ -2045,7 +2045,7 @@ impl Type {
        fn walk_substs(
            db: &dyn HirDatabase,
            type_: &Type,
-            substs: &Substs,
+            substs: &Substitution,
            cb: &mut impl FnMut(Type),
        ) {
            for ty in substs.iter() {
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index c7e0d0be3..e0eb2a66d 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -836,7 +836,7 @@ impl<'a> SemanticsScope<'a> {
                resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
                resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(id.into()),
                resolver::ScopeDef::Local(pat_id) => {
-                    let parent = resolver.body_owner().unwrap().into();
+                    let parent = resolver.body_owner().unwrap();
                    ScopeDef::Local(Local { parent, pat_id })
                }
            };
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 4d59293e9..37d162b32 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -20,7 +20,7 @@ use hir_def::{
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
    diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
-    InferenceResult, Substs,
+    InferenceResult, Substitution,
 };
 use syntax::{
    ast::{self, AstNode},
@@ -329,7 +329,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        krate: CrateId,
-        substs: &Substs,
+        substs: &Substitution,
        variant: VariantId,
        missing_fields: Vec<LocalFieldId>,
    ) -> Vec<(Field, Type)> {
@@ -484,7 +484,7 @@ fn resolve_hir_path_(
        resolver.resolve_path_in_value_ns_fully(db.upcast(), path.mod_path()).and_then(|val| {
            let res = match val {
                ValueNs::LocalBinding(pat_id) => {
-                    let var = Local { parent: body_owner?.into(), pat_id };
+                    let var = Local { parent: body_owner?, pat_id };
                    PathResolution::Local(var)
                }
                ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 7a6a41dc2..7ba53ee5c 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -333,7 +333,7 @@ impl Attrs {
        if docs.is_empty() {
            None
        } else {
-            Some(Documentation(docs.into()))
+            Some(Documentation(docs))
        }
    }
 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 8bcc350ce..1080d9c2c 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -32,6 +32,7 @@ use crate::{
    path::{ModPath, Path},
    src::HasSource,
    AsMacroCall, BlockId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleId,
+    UnresolvedMacro,
 };
 /// A subset of Expander that only deals with cfg attributes. We only need it to
@@ -101,10 +102,12 @@ impl Expander {
        &mut self,
        db: &dyn DefDatabase,
        macro_call: ast::MacroCall,
-    ) -> ExpandResult<Option<(Mark, T)>> {
+    ) -> Result<ExpandResult<Option<(Mark, T)>>, UnresolvedMacro> {
        if self.recursion_limit + 1 > EXPANSION_RECURSION_LIMIT {
            cov_mark::hit!(your_stack_belongs_to_me);
-            return ExpandResult::str_err("reached recursion limit during macro expansion".into());
+            return Ok(ExpandResult::str_err(
+                "reached recursion limit during macro expansion".into(),
+            ));
        }
        let macro_call = InFile::new(self.current_file_id, &macro_call);
@@ -116,14 +119,11 @@ impl Expander {
        let call_id =
            macro_call.as_call_id_with_errors(db, self.def_map.krate(), resolver, &mut |e| {
                err.get_or_insert(e);
-            });
+            })?;
        let call_id = match call_id {
-            Some(it) => it,
+            Ok(it) => it,
-            None => {
+            Err(_) => {
-                if err.is_none() {
+                return Ok(ExpandResult { value: None, err });
-                    log::warn!("no error despite `as_call_id_with_errors` returning `None`");
-                }
-                return ExpandResult { value: None, err };
            }
        };
@@ -141,9 +141,9 @@ impl Expander {
                    log::warn!("no error despite `parse_or_expand` failing");
                }
-                return ExpandResult::only_err(err.unwrap_or_else(|| {
+                return Ok(ExpandResult::only_err(err.unwrap_or_else(|| {
                    mbe::ExpandError::Other("failed to parse macro invocation".into())
-                }));
+                })));
            }
        };
@@ -151,7 +151,7 @@ impl Expander {
            Some(it) => it,
            None => {
                // This can happen without being an error, so only forward previous errors.
-                return ExpandResult { value: None, err };
+                return Ok(ExpandResult { value: None, err });
            }
        };
@@ -167,7 +167,7 @@ impl Expander {
        self.current_file_id = file_id;
        self.ast_id_map = db.ast_id_map(file_id);
-        ExpandResult { value: Some((mark, node)), err }
+        Ok(ExpandResult { value: Some((mark, node)), err })
    }
    pub(crate) fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
diff --git a/crates/hir_def/src/body/diagnostics.rs b/crates/hir_def/src/body/diagnostics.rs
index 1de7d30e2..f6992c9a8 100644
--- a/crates/hir_def/src/body/diagnostics.rs
+++ b/crates/hir_def/src/body/diagnostics.rs
@@ -2,13 +2,14 @@
 use hir_expand::diagnostics::DiagnosticSink;
-use crate::diagnostics::{InactiveCode, MacroError, UnresolvedProcMacro};
+use crate::diagnostics::{InactiveCode, MacroError, UnresolvedMacroCall, UnresolvedProcMacro};
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum BodyDiagnostic {
    InactiveCode(InactiveCode),
    MacroError(MacroError),
    UnresolvedProcMacro(UnresolvedProcMacro),
+    UnresolvedMacroCall(UnresolvedMacroCall),
 }
 impl BodyDiagnostic {
@@ -23,6 +24,9 @@ impl BodyDiagnostic {
            BodyDiagnostic::UnresolvedProcMacro(diag) => {
                sink.push(diag.clone());
            }
+            BodyDiagnostic::UnresolvedMacroCall(diag) => {
+                sink.push(diag.clone());
+            }
        }
    }
 }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 7052058f2..60b25db56 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -24,7 +24,7 @@ use crate::{
    body::{Body, BodySourceMap, Expander, LabelSource, PatPtr, SyntheticSyntax},
    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
    db::DefDatabase,
-    diagnostics::{InactiveCode, MacroError, UnresolvedProcMacro},
+    diagnostics::{InactiveCode, MacroError, UnresolvedMacroCall, UnresolvedProcMacro},
    expr::{
        dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Label,
        LabelId, Literal, LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField,
@@ -33,7 +33,7 @@ use crate::{
    item_scope::BuiltinShadowMode,
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
-    AdtId, BlockLoc, ModuleDefId,
+    AdtId, BlockLoc, ModuleDefId, UnresolvedMacro,
 };
 use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
@@ -554,6 +554,17 @@ impl ExprCollector<'_> {
        let macro_call = self.expander.to_source(AstPtr::new(&e));
        let res = self.expander.enter_expand(self.db, e);
+        let res = match res {
+            Ok(res) => res,
+            Err(UnresolvedMacro) => {
+                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedMacroCall(
+                    UnresolvedMacroCall { file: outer_file, node: syntax_ptr.cast().unwrap() },
+                ));
+                collector(self, None);
+                return;
+            }
+        };
        match &res.err {
            Some(ExpandError::UnresolvedProcMacro) => {
                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro(
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index 991a32b15..f8e6f70e8 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -175,6 +175,18 @@ fn f() {
 }
 #[test]
+fn unresolved_macro_diag() {
+    check_diagnostics(
+        r#"
+fn f() {
+    m!();
+  //^^^^ unresolved macro call
+}
+      "#,
+    );
+}
+#[test]
 fn dollar_crate_in_builtin_macro() {
    check_diagnostics(
        r#"
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 74a2194e5..1a27f7bf2 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -267,23 +267,26 @@ fn collect_items(
                let ast_id_map = db.ast_id_map(file_id);
                let root = db.parse_or_expand(file_id).unwrap();
                let call = ast_id_map.get(call.ast_id).to_node(&root);
+                let res = expander.enter_expand(db, call);
-                if let Some((mark, mac)) = expander.enter_expand(db, call).value {
-                    let src: InFile<ast::MacroItems> = expander.to_source(mac);
+                if let Ok(res) = res {
-                    let item_tree = db.item_tree(src.file_id);
+                    if let Some((mark, mac)) = res.value {
-                    let iter =
+                        let src: InFile<ast::MacroItems> = expander.to_source(mac);
-                        item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
+                        let item_tree = db.item_tree(src.file_id);
-                    items.extend(collect_items(
+                        let iter =
-                        db,
+                            item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
-                        module,
+                        items.extend(collect_items(
-                        expander,
+                            db,
-                        iter,
+                            module,
-                        src.file_id,
+                            expander,
-                        container,
+                            iter,
-                        limit - 1,
+                            src.file_id,
-                    ));
+                            container,
+                            limit - 1,
-                    expander.exit(db, mark);
+                        ));
+                        expander.exit(db, mark);
+                    }
                }
            }
        }
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index 7188bb299..97abf8653 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -99,7 +99,7 @@ impl Diagnostic for UnresolvedImport {
 //
 // This diagnostic is triggered if rust-analyzer is unable to resolve the path to a
 // macro in a macro invocation.
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct UnresolvedMacroCall {
    pub file: HirFileId,
    pub node: AstPtr<ast::MacroCall>,
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index c6655c5fb..6758411a0 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -58,7 +58,7 @@ use std::{
 use base_db::{impl_intern_key, salsa, CrateId};
 use hir_expand::{
    ast_id_map::FileAstId,
-    eager::{expand_eager_macro, ErrorEmitted},
+    eager::{expand_eager_macro, ErrorEmitted, ErrorSink},
    hygiene::Hygiene,
    AstId, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
@@ -583,7 +583,7 @@ pub trait AsMacroCall {
        krate: CrateId,
        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
    ) -> Option<MacroCallId> {
-        self.as_call_id_with_errors(db, krate, resolver, &mut |_| ())
+        self.as_call_id_with_errors(db, krate, resolver, &mut |_| ()).ok()?.ok()
    }
    fn as_call_id_with_errors(
@@ -592,7 +592,7 @@ pub trait AsMacroCall {
        krate: CrateId,
        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
        error_sink: &mut dyn FnMut(mbe::ExpandError),
-    ) -> Option<MacroCallId>;
+    ) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro>;
 }
 impl AsMacroCall for InFile<&ast::MacroCall> {
@@ -601,25 +601,28 @@ impl AsMacroCall for InFile<&ast::MacroCall> {
        db: &dyn db::DefDatabase,
        krate: CrateId,
        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
-        error_sink: &mut dyn FnMut(mbe::ExpandError),
+        mut error_sink: &mut dyn FnMut(mbe::ExpandError),
-    ) -> Option<MacroCallId> {
+    ) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro> {
        let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));
        let h = Hygiene::new(db.upcast(), self.file_id);
        let path = self.value.path().and_then(|path| path::ModPath::from_src(path, &h));
-        if path.is_none() {
+        let path = match error_sink
-            error_sink(mbe::ExpandError::Other("malformed macro invocation".into()));
+            .option(path, || mbe::ExpandError::Other("malformed macro invocation".into()))
-        }
+        {
+            Ok(path) => path,
+            Err(error) => {
+                return Ok(Err(error));
+            }
+        };
        macro_call_as_call_id(
-            &AstIdWithPath::new(ast_id.file_id, ast_id.value, path?),
+            &AstIdWithPath::new(ast_id.file_id, ast_id.value, path),
            db,
            krate,
            resolver,
            error_sink,
        )
-        .ok()?
-        .ok()
    }
 }
@@ -636,7 +639,7 @@ impl<T: ast::AstNode> AstIdWithPath<T> {
    }
 }
-struct UnresolvedMacro;
+pub struct UnresolvedMacro;
 fn macro_call_as_call_id(
    call: &AstIdWithPath<ast::MacroCall>,
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index ae7b51a08..dc618a9ee 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -35,7 +35,7 @@ pub struct ErrorEmitted {
    _private: (),
 }
-trait ErrorSink {
+pub trait ErrorSink {
    fn emit(&mut self, err: mbe::ExpandError);
    fn option<T>(
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index c8ea81210..87cad326d 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -23,7 +23,7 @@ pub struct Hygiene {
 impl Hygiene {
    pub fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Hygiene {
-        Hygiene { frames: Some(HygieneFrames::new(db, file_id.clone())) }
+        Hygiene { frames: Some(HygieneFrames::new(db, file_id)) }
    }
    pub fn new_unhygienic() -> Hygiene {
@@ -129,10 +129,7 @@ impl HygieneInfo {
            mbe::Origin::Call => (&self.macro_arg.1, self.arg_start),
            mbe::Origin::Def => (
                &self.macro_def.1,
-                self.def_start
+                *self.def_start.as_ref().expect("`Origin::Def` used with non-`macro_rules!` macro"),
-                    .as_ref()
-                    .expect("`Origin::Def` used with non-`macro_rules!` macro")
-                    .clone(),
            ),
        };
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index eee430af1..7532d00b8 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -475,7 +475,7 @@ fn original_range_opt(
    let single = skip_trivia_token(node.value.first_token()?, Direction::Next)?
        == skip_trivia_token(node.value.last_token()?, Direction::Prev)?;
-    Some(node.value.descendants().find_map(|it| {
+    node.value.descendants().find_map(|it| {
        let first = skip_trivia_token(it.first_token()?, Direction::Next)?;
        let first = ascend_call_token(db, &expansion, node.with_value(first))?;
@@ -487,7 +487,7 @@ fn original_range_opt(
        }
        Some(first.with_value(first.value.text_range().cover(last.value.text_range())))
-    })?)
+    })
 }
 fn ascend_call_token(
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index 56c6b92d4..bd2ff5d38 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -15,7 +15,7 @@ use crate::{
    to_assoc_type_id,
    traits::{InEnvironment, Solution},
    utils::generics,
-    BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substs, TraitRef, Ty, TyKind,
+    BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -65,7 +65,7 @@ fn deref_by_trait(
    // FIXME make the Canonical / bound var handling nicer
    let parameters =
-        Substs::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
+        Substitution::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
    // Check that the type implements Deref at all
    let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() };
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 982ad5b9e..bfe239793 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -203,7 +203,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: fn_src.file_id,
                ident_type: IdentType::Function,
-                ident: AstPtr::new(&ast_ptr).into(),
+                ident: AstPtr::new(&ast_ptr),
                expected_case: replacement.expected_case,
                ident_text: replacement.current_name.to_string(),
                suggested_text: replacement.suggested_text,
@@ -261,7 +261,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: fn_src.file_id,
                ident_type: IdentType::Argument,
-                ident: AstPtr::new(&ast_ptr).into(),
+                ident: AstPtr::new(&ast_ptr),
                expected_case: param_to_rename.expected_case,
                ident_text: param_to_rename.current_name.to_string(),
                suggested_text: param_to_rename.suggested_text,
@@ -313,7 +313,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
                        let diagnostic = IncorrectCase {
                            file: source_ptr.file_id,
                            ident_type: IdentType::Variable,
-                            ident: AstPtr::new(&name_ast).into(),
+                            ident: AstPtr::new(&name_ast),
                            expected_case: replacement.expected_case,
                            ident_text: replacement.current_name.to_string(),
                            suggested_text: replacement.suggested_text,
@@ -403,7 +403,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: struct_src.file_id,
                ident_type: IdentType::Structure,
-                ident: AstPtr::new(&ast_ptr).into(),
+                ident: AstPtr::new(&ast_ptr),
                expected_case: replacement.expected_case,
                ident_text: replacement.current_name.to_string(),
                suggested_text: replacement.suggested_text,
@@ -448,7 +448,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: struct_src.file_id,
                ident_type: IdentType::Field,
-                ident: AstPtr::new(&ast_ptr).into(),
+                ident: AstPtr::new(&ast_ptr),
                expected_case: field_to_rename.expected_case,
                ident_text: field_to_rename.current_name.to_string(),
                suggested_text: field_to_rename.suggested_text,
@@ -527,7 +527,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: enum_src.file_id,
                ident_type: IdentType::Enum,
-                ident: AstPtr::new(&ast_ptr).into(),
+                ident: AstPtr::new(&ast_ptr),
                expected_case: replacement.expected_case,
                ident_text: replacement.current_name.to_string(),
                suggested_text: replacement.suggested_text,
@@ -572,7 +572,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            let diagnostic = IncorrectCase {
                file: enum_src.file_id,
                ident_type: IdentType::Variant,
-                ident: AstPtr::new(&ast_ptr).into(),
+                ident: AstPtr::new(&ast_ptr),
                expected_case: variant_to_rename.expected_case,
                ident_text: variant_to_rename.current_name.to_string(),
                suggested_text: variant_to_rename.suggested_text,
@@ -617,7 +617,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let diagnostic = IncorrectCase {
            file: const_src.file_id,
            ident_type: IdentType::Constant,
-            ident: AstPtr::new(&ast_ptr).into(),
+            ident: AstPtr::new(&ast_ptr),
            expected_case: replacement.expected_case,
            ident_text: replacement.current_name.to_string(),
            suggested_text: replacement.suggested_text,
@@ -665,7 +665,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let diagnostic = IncorrectCase {
            file: static_src.file_id,
            ident_type: IdentType::StaticVariable,
-            ident: AstPtr::new(&ast_ptr).into(),
+            ident: AstPtr::new(&ast_ptr),
            expected_case: replacement.expected_case,
            ident_text: replacement.current_name.to_string(),
            suggested_text: replacement.suggested_text,
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index b2bfd68d4..71b2cade0 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -44,7 +44,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
        self.check_for_filter_map_next(db);
-        let body = db.body(self.owner.into());
+        let body = db.body(self.owner);
        for (id, expr) in body.exprs.iter() {
            if let Some((variant_def, missed_fields, true)) =
@@ -98,7 +98,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        missed_fields: Vec<LocalFieldId>,
    ) {
        // XXX: only look at source_map if we do have missing fields
-        let (_, source_map) = db.body_with_source_map(self.owner.into());
+        let (_, source_map) = db.body_with_source_map(self.owner);
        if let Ok(source_ptr) = source_map.expr_syntax(id) {
            let root = source_ptr.file_syntax(db.upcast());
@@ -128,7 +128,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        missed_fields: Vec<LocalFieldId>,
    ) {
        // XXX: only look at source_map if we do have missing fields
-        let (_, source_map) = db.body_with_source_map(self.owner.into());
+        let (_, source_map) = db.body_with_source_map(self.owner);
        if let Ok(source_ptr) = source_map.pat_syntax(id) {
            if let Some(expr) = source_ptr.value.as_ref().left() {
@@ -175,7 +175,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        };
        // Search function body for instances of .filter_map(..).next()
-        let body = db.body(self.owner.into());
+        let body = db.body(self.owner);
        let mut prev = None;
        for (id, expr) in body.exprs.iter() {
            if let Expr::MethodCall { receiver, .. } = expr {
@@ -192,7 +192,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                if function_id == *next_function_id {
                    if let Some(filter_map_id) = prev {
                        if *receiver == filter_map_id {
-                            let (_, source_map) = db.body_with_source_map(self.owner.into());
+                            let (_, source_map) = db.body_with_source_map(self.owner);
                            if let Ok(next_source_ptr) = source_map.expr_syntax(id) {
                                self.sink.push(ReplaceFilterMapNextWithFindMap {
                                    file: next_source_ptr.file_id,
@@ -262,7 +262,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        let mut arg_count = args.len();
        if arg_count != param_count {
-            let (_, source_map) = db.body_with_source_map(self.owner.into());
+            let (_, source_map) = db.body_with_source_map(self.owner);
            if let Ok(source_ptr) = source_map.expr_syntax(call_id) {
                if is_method_call {
                    param_count -= 1;
@@ -287,7 +287,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        infer: Arc<InferenceResult>,
    ) {
        let (body, source_map): (Arc<Body>, Arc<BodySourceMap>) =
-            db.body_with_source_map(self.owner.into());
+            db.body_with_source_map(self.owner);
        let match_expr_ty = if infer.type_of_expr[match_expr].is_unknown() {
            return;
@@ -393,7 +393,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        };
        if params.len() > 0 && params[0] == mismatch.actual {
-            let (_, source_map) = db.body_with_source_map(self.owner.into());
+            let (_, source_map) = db.body_with_source_map(self.owner);
            if let Ok(source_ptr) = source_map.expr_syntax(id) {
                self.sink.push(MissingOkOrSomeInTailExpr {
@@ -425,7 +425,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            return;
        }
-        let (_, source_map) = db.body_with_source_map(self.owner.into());
+        let (_, source_map) = db.body_with_source_map(self.owner);
        if let Ok(source_ptr) = source_map.expr_syntax(possible_tail_id) {
            self.sink
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 44a7e5506..1f49a4909 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -29,7 +29,7 @@ impl<'a, 'b> UnsafeValidator<'a, 'b> {
    }
    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let def = self.owner.into();
+        let def = self.owner;
        let unsafe_expressions = unsafe_expressions(db, self.infer.as_ref(), def);
        let is_unsafe = match self.owner {
            DefWithBodyId::FunctionId(it) => db.function_data(it).qualifier.is_unsafe,
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index c572bb114..7ce0f864c 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -20,7 +20,7 @@ use crate::{
    db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasTy, CallableDefId,
    CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
-    ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind,
+    ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
 };
 pub struct HirFormatter<'a> {
@@ -562,7 +562,7 @@ impl HirDisplay for Ty {
                    }
                    TypeParamProvenance::ArgumentImplTrait => {
                        let bounds = f.db.generic_predicates_for_param(id);
-                        let substs = Substs::type_params_for_generics(f.db, &generics);
+                        let substs = Substitution::type_params_for_generics(f.db, &generics);
                        write_bounds_like_dyn_trait_with_prefix(
                            "impl",
                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 9c385b845..2610c9279 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -38,7 +38,7 @@ use syntax::SmolStr;
 use super::{
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
+    InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
@@ -390,7 +390,7 @@ impl<'a> InferenceContext<'a> {
                    _ => panic!("resolve_associated_type called with non-associated type"),
                };
                let ty = self.table.new_type_var();
-                let substs = Substs::build_for_def(self.db, res_assoc_ty)
+                let substs = Substitution::build_for_def(self.db, res_assoc_ty)
                    .push(inner_ty)
                    .fill(params.iter().cloned())
                    .build();
@@ -469,7 +469,7 @@ impl<'a> InferenceContext<'a> {
            }
            TypeNs::SelfType(impl_id) => {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
-                let substs = Substs::type_params_for_generics(self.db, &generics);
+                let substs = Substitution::type_params_for_generics(self.db, &generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
                match unresolved {
                    None => {
@@ -496,7 +496,7 @@ impl<'a> InferenceContext<'a> {
                }
            }
            TypeNs::TypeAliasId(it) => {
-                let substs = Substs::build_for_def(self.db, it)
+                let substs = Substitution::build_for_def(self.db, it)
                    .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                    .build();
                let ty = self.db.ty(it.into()).subst(&substs);
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 137419264..b1f98c507 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -7,7 +7,9 @@
 use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
-use crate::{autoderef, traits::Solution, Interner, Obligation, Substs, TraitRef, Ty, TyKind};
+use crate::{
+    autoderef, traits::Solution, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
+};
 use super::{InEnvironment, InferenceContext};
@@ -134,7 +136,7 @@ impl<'a> InferenceContext<'a> {
            return None;
        }
-        let substs = Substs::build_for_generics(&generic_params)
+        let substs = Substitution::build_for_generics(&generic_params)
            .push(from_ty.clone())
            .push(to_ty.clone())
            .build();
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index f40dec17f..0be8c5a90 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -21,8 +21,8 @@ use crate::{
    to_assoc_type_id,
    traits::{chalk::from_chalk, FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
-    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs,
+    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar,
-    TraitRef, Ty, TyKind,
+    Substitution, TraitRef, Ty, TyKind,
 };
 use super::{
@@ -77,7 +77,7 @@ impl<'a> InferenceContext<'a> {
            return None;
        }
-        let mut param_builder = Substs::builder(num_args);
+        let mut param_builder = Substitution::builder(num_args);
        let mut arg_tys = vec![];
        for _ in 0..num_args {
            let arg = self.table.new_type_var();
@@ -87,7 +87,7 @@ impl<'a> InferenceContext<'a> {
        let parameters = param_builder.build();
        let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner);
        let substs =
-            Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
+            Substitution::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
        let trait_env = Arc::clone(&self.trait_env);
        let implements_fn_trait =
@@ -181,7 +181,7 @@ impl<'a> InferenceContext<'a> {
                let inner_ty = self.infer_expr(*body, &Expectation::none());
                let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body);
                let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
-                TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner)
+                TyKind::OpaqueType(opaque_ty_id, Substitution::single(inner_ty)).intern(&Interner)
            }
            Expr::Loop { body, label } => {
                self.breakables.push(BreakableContext {
@@ -262,12 +262,12 @@ impl<'a> InferenceContext<'a> {
                let sig_ty = TyKind::Function(FnPointer {
                    num_args: sig_tys.len() - 1,
                    sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false },
-                    substs: Substs(sig_tys.clone().into()),
+                    substs: Substitution(sig_tys.clone().into()),
                })
                .intern(&Interner);
                let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
                let closure_ty =
-                    TyKind::Closure(closure_id, Substs::single(sig_ty)).intern(&Interner);
+                    TyKind::Closure(closure_id, Substitution::single(sig_ty)).intern(&Interner);
                // Eagerly try to relate the closure type with the expected
                // type, otherwise we often won't have enough information to
@@ -402,7 +402,7 @@ impl<'a> InferenceContext<'a> {
                self.unify(&ty, &expected.ty);
-                let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
+                let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
                let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
                let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
                for field in fields.iter() {
@@ -511,7 +511,8 @@ impl<'a> InferenceContext<'a> {
            Expr::Box { expr } => {
                let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
                if let Some(box_) = self.resolve_boxed_box() {
-                    let mut sb = Substs::builder(generics(self.db.upcast(), box_.into()).len());
+                    let mut sb =
+                        Substitution::builder(generics(self.db.upcast(), box_.into()).len());
                    sb = sb.push(inner_ty);
                    match self.db.generic_defaults(box_.into()).as_ref() {
                        [_, alloc_ty, ..] if !alloc_ty.value.is_unknown() => {
@@ -610,31 +611,31 @@ impl<'a> InferenceContext<'a> {
                let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
                match (range_type, lhs_ty, rhs_ty) {
                    (RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::empty()),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::empty()),
                        None => self.err_ty(),
                    },
                    (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, None, Some(ty)) => {
                        match self.resolve_range_to_inclusive() {
-                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                            Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                            None => self.err_ty(),
                        }
                    }
                    (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, Some(_), Some(ty)) => {
                        match self.resolve_range_inclusive() {
-                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                            Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                            None => self.err_ty(),
                        }
                    }
                    (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, _, None) => self.err_ty(),
@@ -681,7 +682,7 @@ impl<'a> InferenceContext<'a> {
                    self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
                }
-                TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner)
+                TyKind::Tuple(tys.len(), Substitution(tys.into())).intern(&Interner)
            }
            Expr::Array(array) => {
                let elem_ty = match expected.ty.interned(&Interner) {
@@ -887,7 +888,7 @@ impl<'a> InferenceContext<'a> {
        def_generics: Option<Generics>,
        generic_args: Option<&GenericArgs>,
        receiver_ty: &Ty,
-    ) -> Substs {
+    ) -> Substitution {
        let (parent_params, self_params, type_params, impl_trait_params) =
            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
@@ -926,7 +927,7 @@ impl<'a> InferenceContext<'a> {
            substs.push(self.err_ty());
        }
        assert_eq!(substs.len(), total_len);
-        Substs(substs.into())
+        Substitution(substs.into())
    }
    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 9e8ca18ef..befa0d69b 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -12,7 +12,9 @@ use hir_def::{
 use hir_expand::name::Name;
 use super::{BindingMode, Expectation, InferenceContext};
-use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substs, Ty, TyKind};
+use crate::{
+    lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyKind,
+};
 impl<'a> InferenceContext<'a> {
    fn infer_tuple_struct_pat(
@@ -31,7 +33,7 @@ impl<'a> InferenceContext<'a> {
        }
        self.unify(&ty, expected);
-        let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
+        let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        let (pre, post) = match ellipsis {
@@ -70,7 +72,7 @@ impl<'a> InferenceContext<'a> {
        self.unify(&ty, expected);
-        let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
+        let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        for subpat in subpats {
@@ -138,7 +140,7 @@ impl<'a> InferenceContext<'a> {
                inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
                inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat));
-                TyKind::Tuple(inner_tys.len(), Substs(inner_tys.into())).intern(&Interner)
+                TyKind::Tuple(inner_tys.len(), Substitution(inner_tys.into())).intern(&Interner)
            }
            Pat::Or(ref pats) => {
                if let Some((first_pat, rest)) = pats.split_first() {
@@ -237,7 +239,7 @@ impl<'a> InferenceContext<'a> {
                    };
                    let inner_ty = self.infer_pat(*inner, &inner_expected, default_bm);
-                    Ty::adt_ty(box_adt, Substs::single(inner_ty))
+                    Ty::adt_ty(box_adt, Substitution::single(inner_ty))
                }
                None => self.err_ty(),
            },
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index af108fb6c..ea01d6238 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -9,7 +9,7 @@ use hir_def::{
 };
 use hir_expand::name::Name;
-use crate::{method_resolution, Interner, Substs, Ty, TyKind, ValueTyDefId};
+use crate::{method_resolution, Interner, Substitution, Ty, TyKind, ValueTyDefId};
 use super::{ExprOrPatId, InferenceContext, TraitRef};
@@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> {
            }
            ValueNs::ImplSelf(impl_id) => {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
-                let substs = Substs::type_params_for_generics(self.db, &generics);
+                let substs = Substitution::type_params_for_generics(self.db, &generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
                if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
                    let ty = self.db.value_ty(struct_id.into()).subst(&substs);
@@ -94,10 +94,10 @@ impl<'a> InferenceContext<'a> {
        let ty = self.db.value_ty(typable);
        // self_subst is just for the parent
-        let parent_substs = self_subst.unwrap_or_else(Substs::empty);
+        let parent_substs = self_subst.unwrap_or_else(Substitution::empty);
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
        let substs = ctx.substs_from_path(path, typable, true);
-        let full_substs = Substs::builder(substs.len())
+        let full_substs = Substitution::builder(substs.len())
            .use_parent_substs(&parent_substs)
            .fill(substs.0[parent_substs.len()..].iter().cloned())
            .build();
@@ -111,7 +111,7 @@ impl<'a> InferenceContext<'a> {
        path: &Path,
        remaining_index: usize,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        assert!(remaining_index < path.segments().len());
        // there may be more intermediate segments between the resolved one and
        // the end. Only the last segment needs to be resolved to a value; from
@@ -164,7 +164,7 @@ impl<'a> InferenceContext<'a> {
        trait_ref: TraitRef,
        segment: PathSegment<'_>,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        let trait_ = trait_ref.trait_;
        let item =
            self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| {
@@ -208,7 +208,7 @@ impl<'a> InferenceContext<'a> {
        ty: Ty,
        name: &Name,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        if let TyKind::Unknown = ty.interned(&Interner) {
            return None;
        }
@@ -241,7 +241,7 @@ impl<'a> InferenceContext<'a> {
                };
                let substs = match container {
                    AssocContainerId::ImplId(impl_id) => {
-                        let impl_substs = Substs::build_for_def(self.db, impl_id)
+                        let impl_substs = Substitution::build_for_def(self.db, impl_id)
                            .fill(iter::repeat_with(|| self.table.new_type_var()))
                            .build();
                        let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs);
@@ -250,7 +250,7 @@ impl<'a> InferenceContext<'a> {
                    }
                    AssocContainerId::TraitId(trait_) => {
                        // we're picking this method
-                        let trait_substs = Substs::build_for_def(self.db, trait_)
+                        let trait_substs = Substitution::build_for_def(self.db, trait_)
                            .push(ty.clone())
                            .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                            .build();
@@ -274,7 +274,7 @@ impl<'a> InferenceContext<'a> {
        ty: &Ty,
        name: &Name,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        let (enum_id, subst) = match ty.as_adt() {
            Some((AdtId::EnumId(e), subst)) => (e, subst),
            _ => return None,
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 7795f446f..b2d4f67b3 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -8,7 +8,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{InferenceContext, Obligation};
 use crate::{
    BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar,
-    Interner, Scalar, Substs, Ty, TyKind, TypeWalk,
+    Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -123,10 +123,10 @@ impl<T> Canonicalized<T> {
    pub(super) fn apply_solution(
        &self,
        ctx: &mut InferenceContext<'_>,
-        solution: Canonical<Substs>,
+        solution: Canonical<Substitution>,
    ) {
        // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars = Substs(
+        let new_vars = Substitution(
            solution
                .kinds
                .iter()
@@ -147,9 +147,9 @@ impl<T> Canonicalized<T> {
    }
 }
-pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
+pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
    let mut table = InferenceTable::new();
-    let vars = Substs(
+    let vars = Substitution(
        tys.kinds
            .iter()
            // we always use type vars here because we want everything to
@@ -173,7 +173,7 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
        }
    }
    Some(
-        Substs::builder(tys.kinds.len())
+        Substitution::builder(tys.kinds.len())
            .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
            .build(),
    )
@@ -264,8 +264,8 @@ impl InferenceTable {
    pub(crate) fn unify_substs(
        &mut self,
-        substs1: &Substs,
+        substs1: &Substitution,
-        substs2: &Substs,
+        substs2: &Substitution,
        depth: usize,
    ) -> bool {
        substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 850385280..52b498ff7 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -67,7 +67,7 @@ pub enum Lifetime {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct OpaqueTy {
    pub opaque_ty_id: OpaqueTyId,
-    pub substitution: Substs,
+    pub substitution: Substitution,
 }
 /// A "projection" type corresponds to an (unnormalized)
@@ -76,7 +76,7 @@ pub struct OpaqueTy {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct ProjectionTy {
    pub associated_ty_id: AssocTypeId,
-    pub substitution: Substs,
+    pub substitution: Substitution,
 }
 impl ProjectionTy {
@@ -112,7 +112,7 @@ pub type FnSig = chalk_ir::FnSig<Interner>;
 pub struct FnPointer {
    pub num_args: usize,
    pub sig: FnSig,
-    pub substs: Substs,
+    pub substs: Substitution,
 }
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -137,19 +137,19 @@ pub enum AliasTy {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum TyKind {
    /// Structures, enumerations and unions.
-    Adt(AdtId<Interner>, Substs),
+    Adt(AdtId<Interner>, Substitution),
    /// Represents an associated item like `Iterator::Item`.  This is used
    /// when we have tried to normalize a projection like `T::Item` but
    /// couldn't find a better representation.  In that case, we generate
    /// an **application type** like `(Iterator::Item)<T>`.
-    AssociatedType(AssocTypeId, Substs),
+    AssociatedType(AssocTypeId, Substitution),
    /// a scalar type like `bool` or `u32`
    Scalar(Scalar),
    /// A tuple type.  For example, `(i32, bool)`.
-    Tuple(usize, Substs),
+    Tuple(usize, Substitution),
    /// An array with the given length. Written as `[T; n]`.
    Array(Ty),
@@ -169,7 +169,7 @@ pub enum TyKind {
    /// analogous to the `AssociatedType` type constructor.
    /// It is also used as the type of async block, with one type parameter
    /// representing the Future::Output type.
-    OpaqueType(OpaqueTyId, Substs),
+    OpaqueType(OpaqueTyId, Substitution),
    /// The anonymous type of a function declaration/definition. Each
    /// function has a unique type, which is output (for a function
@@ -183,7 +183,7 @@ pub enum TyKind {
    /// fn foo() -> i32 { 1 }
    /// let bar = foo; // bar: fn() -> i32 {foo}
    /// ```
-    FnDef(FnDefId, Substs),
+    FnDef(FnDefId, Substitution),
    /// The pointee of a string slice. Written as `str`.
    Str,
@@ -195,7 +195,7 @@ pub enum TyKind {
    ///
    /// The closure signature is stored in a `FnPtr` type in the first type
    /// parameter.
-    Closure(ClosureId, Substs),
+    Closure(ClosureId, Substitution),
    /// Represents a foreign type declared in external blocks.
    ForeignType(ForeignDefId),
@@ -273,9 +273,9 @@ impl Ty {
 /// A list of substitutions for generic parameters.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct Substs(SmallVec<[Ty; 2]>);
+pub struct Substitution(SmallVec<[Ty; 2]>);
-impl TypeWalk for Substs {
+impl TypeWalk for Substitution {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        for t in self.0.iter() {
            t.walk(f);
@@ -293,29 +293,29 @@ impl TypeWalk for Substs {
    }
 }
-impl Substs {
+impl Substitution {
    pub fn interned(&self, _: &Interner) -> &[Ty] {
        &self.0
    }
-    pub fn empty() -> Substs {
+    pub fn empty() -> Substitution {
-        Substs(SmallVec::new())
+        Substitution(SmallVec::new())
    }
-    pub fn single(ty: Ty) -> Substs {
+    pub fn single(ty: Ty) -> Substitution {
-        Substs({
+        Substitution({
            let mut v = SmallVec::new();
            v.push(ty);
            v
        })
    }
-    pub fn prefix(&self, n: usize) -> Substs {
+    pub fn prefix(&self, n: usize) -> Substitution {
-        Substs(self.0[..std::cmp::min(self.0.len(), n)].into())
+        Substitution(self.0[..std::cmp::min(self.0.len(), n)].into())
    }
-    pub fn suffix(&self, n: usize) -> Substs {
+    pub fn suffix(&self, n: usize) -> Substitution {
-        Substs(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
+        Substitution(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
    }
    pub fn as_single(&self) -> &Ty {
@@ -326,15 +326,15 @@ impl Substs {
    }
    pub fn from_iter(_interner: &Interner, elements: impl IntoIterator<Item = Ty>) -> Self {
-        Substs(elements.into_iter().collect())
+        Substitution(elements.into_iter().collect())
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
    pub(crate) fn type_params_for_generics(
        db: &dyn HirDatabase,
        generic_params: &Generics,
-    ) -> Substs {
+    ) -> Substitution {
-        Substs(
+        Substitution(
            generic_params
                .iter()
                .map(|(id, _)| TyKind::Placeholder(to_placeholder_idx(db, id)).intern(&Interner))
@@ -343,14 +343,14 @@ impl Substs {
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
-    pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substs {
+    pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
        let params = generics(db.upcast(), def.into());
-        Substs::type_params_for_generics(db, &params)
+        Substitution::type_params_for_generics(db, &params)
    }
    /// Return Substs that replace each parameter by a bound variable.
-    pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substs {
+    pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substitution {
-        Substs(
+        Substitution(
            generic_params
                .iter()
                .enumerate()
@@ -363,11 +363,11 @@ impl Substs {
        let def = def.into();
        let params = generics(db.upcast(), def);
        let param_count = params.len();
-        Substs::builder(param_count)
+        Substitution::builder(param_count)
    }
    pub(crate) fn build_for_generics(generic_params: &Generics) -> SubstsBuilder {
-        Substs::builder(generic_params.len())
+        Substitution::builder(generic_params.len())
    }
    fn builder(param_count: usize) -> SubstsBuilder {
@@ -387,9 +387,9 @@ pub struct SubstsBuilder {
 }
 impl SubstsBuilder {
-    pub fn build(self) -> Substs {
+    pub fn build(self) -> Substitution {
        assert_eq!(self.vec.len(), self.param_count);
-        Substs(self.vec.into())
+        Substitution(self.vec.into())
    }
    pub fn push(mut self, ty: Ty) -> Self {
@@ -418,7 +418,7 @@ impl SubstsBuilder {
        self
    }
-    pub fn use_parent_substs(mut self, parent_substs: &Substs) -> Self {
+    pub fn use_parent_substs(mut self, parent_substs: &Substitution) -> Self {
        assert!(self.vec.is_empty());
        assert!(parent_substs.len() <= self.param_count);
        self.vec.extend(parent_substs.iter().cloned());
@@ -426,7 +426,7 @@ impl SubstsBuilder {
    }
 }
-impl Deref for Substs {
+impl Deref for Substitution {
    type Target = [Ty];
    fn deref(&self) -> &[Ty] {
@@ -466,13 +466,13 @@ impl<T: Clone> Binders<&T> {
 impl<T: TypeWalk> Binders<T> {
    /// Substitutes all variables.
-    pub fn subst(self, subst: &Substs) -> T {
+    pub fn subst(self, subst: &Substitution) -> 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> {
+    pub fn subst_prefix(self, subst: &Substitution) -> Binders<T> {
        assert!(subst.len() < self.num_binders);
        Binders::new(self.num_binders - subst.len(), self.value.subst_bound_vars(subst))
    }
@@ -498,7 +498,7 @@ impl<T: TypeWalk> TypeWalk for Binders<T> {
 pub struct TraitRef {
    /// FIXME name?
    pub trait_: TraitId,
-    pub substs: Substs,
+    pub substs: Substitution,
 }
 impl TraitRef {
@@ -618,7 +618,7 @@ impl CallableSig {
        }
    }
-    pub fn from_substs(substs: &Substs) -> CallableSig {
+    pub fn from_substs(substs: &Substitution) -> CallableSig {
        CallableSig { params_and_return: substs.iter().cloned().collect(), is_varargs: false }
    }
@@ -651,10 +651,10 @@ impl TypeWalk for CallableSig {
 impl Ty {
    pub fn unit() -> Self {
-        TyKind::Tuple(0, Substs::empty()).intern(&Interner)
+        TyKind::Tuple(0, Substitution::empty()).intern(&Interner)
    }
-    pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty {
+    pub fn adt_ty(adt: hir_def::AdtId, substs: Substitution) -> Ty {
        TyKind::Adt(AdtId(adt), substs).intern(&Interner)
    }
@@ -662,7 +662,7 @@ impl Ty {
        TyKind::Function(FnPointer {
            num_args: sig.params().len(),
            sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs },
-            substs: Substs::from_iter(&Interner, sig.params_and_return.iter().cloned()),
+            substs: Substitution::from_iter(&Interner, sig.params_and_return.iter().cloned()),
        })
        .intern(&Interner)
    }
@@ -709,14 +709,14 @@ impl Ty {
        t
    }
-    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> {
+    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
        match self.interned(&Interner) {
            TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
            _ => None,
        }
    }
-    pub fn as_tuple(&self) -> Option<&Substs> {
+    pub fn as_tuple(&self) -> Option<&Substitution> {
        match self.interned(&Interner) {
            TyKind::Tuple(_, substs) => Some(substs),
            _ => None,
@@ -828,7 +828,7 @@ impl Ty {
    /// Returns the type parameters of this type if it has some (i.e. is an ADT
    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
-    pub fn substs(&self) -> Option<&Substs> {
+    pub fn substs(&self) -> Option<&Substitution> {
        match self.interned(&Interner) {
            TyKind::Adt(_, substs)
            | TyKind::FnDef(_, substs)
@@ -841,7 +841,7 @@ impl Ty {
        }
    }
-    fn substs_mut(&mut self) -> Option<&mut Substs> {
+    fn substs_mut(&mut self) -> Option<&mut Substitution> {
        match self.interned_mut() {
            TyKind::Adt(_, substs)
            | TyKind::FnDef(_, substs)
@@ -869,7 +869,7 @@ impl Ty {
                            // So just provide the Future trait.
                            let impl_bound = GenericPredicate::Implemented(TraitRef {
                                trait_: future_trait,
-                                substs: Substs::empty(),
+                                substs: Substitution::empty(),
                            });
                            Some(vec![impl_bound])
                        } else {
@@ -992,7 +992,7 @@ pub trait TypeWalk {
    }
    /// Substitutes `TyKind::Bound` vars with the given substitution.
-    fn subst_bound_vars(self, substs: &Substs) -> Self
+    fn subst_bound_vars(self, substs: &Substitution) -> Self
    where
        Self: Sized,
    {
@@ -1000,7 +1000,7 @@ pub trait TypeWalk {
    }
    /// Substitutes `TyKind::Bound` vars with the given substitution.
-    fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self
+    fn subst_bound_vars_at_depth(mut self, substs: &Substitution, depth: DebruijnIndex) -> Self
    where
        Self: Sized,
    {
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 6ab757bfc..462882b2b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -35,7 +35,7 @@ use crate::{
    },
    AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
    ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
-    ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
+    ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
 #[derive(Debug)]
@@ -151,7 +151,7 @@ impl<'a> TyLoweringContext<'a> {
            TypeRef::Never => TyKind::Never.intern(&Interner),
            TypeRef::Tuple(inner) => {
                let inner_tys = inner.iter().map(|tr| self.lower_ty(tr));
-                TyKind::Tuple(inner_tys.len(), Substs::from_iter(&Interner, inner_tys))
+                TyKind::Tuple(inner_tys.len(), Substitution::from_iter(&Interner, inner_tys))
                    .intern(&Interner)
            }
            TypeRef::Path(path) => {
@@ -177,7 +177,7 @@ impl<'a> TyLoweringContext<'a> {
            }
            TypeRef::Placeholder => TyKind::Unknown.intern(&Interner),
            TypeRef::Fn(params, is_varargs) => {
-                let substs = Substs(params.iter().map(|tr| self.lower_ty(tr)).collect());
+                let substs = Substitution(params.iter().map(|tr| self.lower_ty(tr)).collect());
                TyKind::Function(FnPointer {
                    num_args: substs.len() - 1,
                    sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs },
@@ -228,7 +228,7 @@ impl<'a> TyLoweringContext<'a> {
                        let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx);
                        let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
                        let generics = generics(self.db.upcast(), func.into());
-                        let parameters = Substs::bound_vars(&generics, self.in_binders);
+                        let parameters = Substitution::bound_vars(&generics, self.in_binders);
                        TyKind::Alias(AliasTy::Opaque(OpaqueTy {
                            opaque_ty_id,
                            substitution: parameters,
@@ -398,10 +398,10 @@ impl<'a> TyLoweringContext<'a> {
                let generics = generics(self.db.upcast(), impl_id.into());
                let substs = match self.type_param_mode {
                    TypeParamLoweringMode::Placeholder => {
-                        Substs::type_params_for_generics(self.db, &generics)
+                        Substitution::type_params_for_generics(self.db, &generics)
                    }
                    TypeParamLoweringMode::Variable => {
-                        Substs::bound_vars(&generics, self.in_binders)
+                        Substitution::bound_vars(&generics, self.in_binders)
                    }
                };
                self.db.impl_self_ty(impl_id).subst(&substs)
@@ -410,10 +410,10 @@ impl<'a> TyLoweringContext<'a> {
                let generics = generics(self.db.upcast(), adt.into());
                let substs = match self.type_param_mode {
                    TypeParamLoweringMode::Placeholder => {
-                        Substs::type_params_for_generics(self.db, &generics)
+                        Substitution::type_params_for_generics(self.db, &generics)
                    }
                    TypeParamLoweringMode::Variable => {
-                        Substs::bound_vars(&generics, self.in_binders)
+                        Substitution::bound_vars(&generics, self.in_binders)
                    }
                };
                self.db.ty(adt.into()).subst(&substs)
@@ -464,7 +464,7 @@ impl<'a> TyLoweringContext<'a> {
                            TypeParamLoweringMode::Placeholder => {
                                // if we're lowering to placeholders, we have to put
                                // them in now
-                                let s = Substs::type_params(
+                                let s = Substitution::type_params(
                                    self.db,
                                    self.resolver.generic_def().expect(
                                        "there should be generics if there's a generic param",
@@ -522,7 +522,7 @@ impl<'a> TyLoweringContext<'a> {
        // special-case enum variants
        resolved: ValueTyDefId,
        infer_args: bool,
-    ) -> Substs {
+    ) -> Substitution {
        let last = path.segments().last().expect("path should have at least one segment");
        let (segment, generic_def) = match resolved {
            ValueTyDefId::FunctionId(it) => (last, Some(it.into())),
@@ -553,7 +553,7 @@ impl<'a> TyLoweringContext<'a> {
        segment: PathSegment<'_>,
        def_generic: Option<GenericDefId>,
        infer_args: bool,
-    ) -> Substs {
+    ) -> Substitution {
        let mut substs = Vec::new();
        let def_generics = def_generic.map(|def| generics(self.db.upcast(), def));
@@ -601,7 +601,7 @@ impl<'a> TyLoweringContext<'a> {
                for default_ty in defaults.iter().skip(substs.len()) {
                    // each default can depend on the previous parameters
-                    let substs_so_far = Substs(substs.clone().into());
+                    let substs_so_far = Substitution(substs.clone().into());
                    substs.push(default_ty.clone().subst(&substs_so_far));
                }
            }
@@ -614,7 +614,7 @@ impl<'a> TyLoweringContext<'a> {
        }
        assert_eq!(substs.len(), total_len);
-        Substs(substs.into())
+        Substitution(substs.into())
    }
    fn lower_trait_ref_from_path(
@@ -656,7 +656,11 @@ impl<'a> TyLoweringContext<'a> {
        self.lower_trait_ref_from_path(path, explicit_self_ty)
    }
-    fn trait_ref_substs_from_path(&self, segment: PathSegment<'_>, resolved: TraitId) -> Substs {
+    fn trait_ref_substs_from_path(
+        &self,
+        segment: PathSegment<'_>,
+        resolved: TraitId,
+    ) -> Substitution {
        self.substs_from_path_segment(segment, Some(resolved.into()), false)
    }
@@ -817,7 +821,7 @@ pub fn associated_type_shorthand_candidates<R>(
                {
                    let trait_ref = TraitRef {
                        trait_: trait_id,
-                        substs: Substs::bound_vars(&generics, DebruijnIndex::INNERMOST),
+                        substs: Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST),
                    };
                    traits_.push(trait_ref);
                }
@@ -945,7 +949,7 @@ pub(crate) fn trait_environment_query(
        // function default implementations (and hypothetical code
        // inside consts or type aliases)
        cov_mark::hit!(trait_self_implements_self);
-        let substs = Substs::type_params(db, trait_id);
+        let substs = Substitution::type_params(db, trait_id);
        let trait_ref = TraitRef { trait_: trait_id, substs };
        let pred = GenericPredicate::Implemented(trait_ref);
        let program_clause: chalk_ir::ProgramClause<Interner> =
@@ -1033,7 +1037,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
 /// function body.
 fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> {
    let generics = generics(db.upcast(), def.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(
        substs.len(),
        TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner),
@@ -1078,7 +1082,7 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T
        return type_for_adt(db, def.into());
    }
    let generics = generics(db.upcast(), def.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(
        substs.len(),
        TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner),
@@ -1105,7 +1109,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
        return type_for_adt(db, def.parent.into());
    }
    let generics = generics(db.upcast(), def.parent.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(
        substs.len(),
        TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner),
@@ -1114,7 +1118,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
 fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
    let generics = generics(db.upcast(), adt.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(substs.len(), Ty::adt_ty(adt, substs))
 }
@@ -1126,7 +1130,7 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
    if db.type_alias_data(t).is_extern {
        Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner))
    } else {
-        let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+        let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
        let type_ref = &db.type_alias_data(t).type_ref;
        let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error));
        Binders::new(substs.len(), inner)
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index be72c4a1c..943d3339b 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -21,7 +21,7 @@ use crate::{
    primitive::{self, FloatTy, IntTy, UintTy},
    utils::all_super_traits,
    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner,
-    Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
+    Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
 /// This is used as a key for indexing impls.
@@ -672,10 +672,10 @@ pub(crate) fn inherent_impl_substs(
    db: &dyn HirDatabase,
    impl_id: ImplId,
    self_ty: &Canonical<Ty>,
-) -> Option<Substs> {
+) -> Option<Substitution> {
    // we create a var for each type parameter of the impl; we need to keep in
    // mind here that `self_ty` might have vars of its own
-    let vars = Substs::build_for_def(db, impl_id)
+    let vars = Substitution::build_for_def(db, impl_id)
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.kinds.len())
        .build();
    let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
@@ -693,7 +693,7 @@ pub(crate) fn inherent_impl_substs(
 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
 /// num_vars_to_keep) by `TyKind::Unknown`.
-fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
+fn fallback_bound_vars(s: Substitution, num_vars_to_keep: usize) -> Substitution {
    s.fold_binders(
        &mut |ty, binders| {
            if let TyKind::BoundVar(bound) = ty.interned(&Interner) {
@@ -716,13 +716,13 @@ fn transform_receiver_ty(
    self_ty: &Canonical<Ty>,
 ) -> Option<Ty> {
    let substs = match function_id.lookup(db.upcast()).container {
-        AssocContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
+        AssocContainerId::TraitId(_) => Substitution::build_for_def(db, function_id)
            .push(self_ty.value.clone())
            .fill_with_unknown()
            .build(),
        AssocContainerId::ImplId(impl_id) => {
            let impl_substs = inherent_impl_substs(db, impl_id, &self_ty)?;
-            Substs::build_for_def(db, function_id)
+            Substitution::build_for_def(db, function_id)
                .use_parent_substs(&impl_substs)
                .fill_with_unknown()
                .build()
@@ -768,7 +768,7 @@ fn generic_implements_goal(
    self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::Obligation>> {
    let mut kinds = self_ty.kinds.to_vec();
-    let substs = super::Substs::build_for_def(db, trait_)
+    let substs = super::Substitution::build_for_def(db, trait_)
        .push(self_ty.value)
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
        .build();
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index a6a63c673..40eb1034e 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -8,7 +8,7 @@ use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
 use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;
-use crate::{db::HirDatabase, DebruijnIndex, Substs};
+use crate::{db::HirDatabase, DebruijnIndex, Substitution};
 use super::{
    Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk,
@@ -252,7 +252,7 @@ fn solution_from_chalk(
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SolutionVariables(pub Canonical<Substs>);
+pub struct SolutionVariables(pub Canonical<Substitution>);
 #[derive(Clone, Debug, PartialEq, Eq)]
 /// A (possible) solution for a proposed goal.
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 4bd8ba303..bef6e7e9c 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -22,7 +22,7 @@ use crate::{
    to_assoc_type_id,
    utils::generics,
    BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
-    ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TyKind,
+    ProjectionPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
 };
 use mapping::{
    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
@@ -221,7 +221,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                    let impl_bound = GenericPredicate::Implemented(TraitRef {
                        trait_: future_trait,
                        // Self type as the first parameter.
-                        substs: Substs::single(
+                        substs: Substitution::single(
                            TyKind::BoundVar(BoundVar {
                                debruijn: DebruijnIndex::INNERMOST,
                                index: 0,
@@ -236,7 +236,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                        projection_ty: ProjectionTy {
                            associated_ty_id: to_assoc_type_id(future_output),
                            // Self type as the first parameter.
-                            substitution: Substs::single(
+                            substitution: Substitution::single(
                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
                                    .intern(&Interner),
                            ),
@@ -313,7 +313,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        _closure_id: chalk_ir::ClosureId<Interner>,
        _substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Substitution<Interner> {
-        Substs::empty().to_chalk(self.db)
+        Substitution::empty().to_chalk(self.db)
    }
    fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
@@ -392,7 +392,7 @@ pub(crate) fn associated_ty_data_query(
    // Lower bounds -- we could/should maybe move this to a separate query in `lower`
    let type_alias_data = db.type_alias_data(type_alias);
    let generic_params = generics(db.upcast(), type_alias.into());
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
    let ctx = crate::TyLoweringContext::new(db, &resolver)
        .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
@@ -427,7 +427,7 @@ pub(crate) fn trait_datum_query(
    let trait_data = db.trait_data(trait_);
    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
    let generic_params = generics(db.upcast(), trait_.into());
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let flags = rust_ir::TraitFlags {
        auto: trait_data.is_auto,
        upstream: trait_.lookup(db.upcast()).container.krate() != krate,
@@ -496,7 +496,7 @@ pub(crate) fn struct_datum_query(
    let upstream = adt_id.module(db.upcast()).krate() != krate;
    let where_clauses = {
        let generic_params = generics(db.upcast(), adt_id.into());
-        let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+        let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
        convert_where_clauses(db, adt_id.into(), &bound_vars)
    };
    let flags = rust_ir::AdtFlags {
@@ -545,7 +545,7 @@ fn impl_def_datum(
    let impl_data = db.impl_data(impl_id);
    let generic_params = generics(db.upcast(), impl_id.into());
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let trait_ = trait_ref.trait_;
    let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
        rust_ir::ImplType::Local
@@ -635,7 +635,7 @@ pub(crate) fn fn_def_datum_query(
    let callable_def: CallableDefId = from_chalk(db, fn_def_id);
    let generic_params = generics(db.upcast(), callable_def.into());
    let sig = db.callable_item_signature(callable_def);
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
    let bound = rust_ir::FnDefDatumBound {
        // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 6a8b6752e..d969527dc 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -15,7 +15,7 @@ use crate::{
    primitive::UintTy,
    traits::{Canonical, Obligation},
    AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy,
-    ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty,
+    ProjectionPredicate, ProjectionTy, Scalar, Substitution, TraitRef, Ty,
 };
 use super::interner::*;
@@ -52,7 +52,7 @@ impl ToChalk for Ty {
            TyKind::Tuple(cardinality, substs) => {
                let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
+                chalk_ir::TyKind::Tuple(cardinality, substitution).intern(&Interner)
            }
            TyKind::Raw(mutability, ty) => {
                let ty = ty.to_chalk(db);
@@ -134,7 +134,7 @@ impl ToChalk for Ty {
                ..
            }) => {
                assert_eq!(num_binders, 0);
-                let substs: Substs = from_chalk(
+                let substs: Substitution = from_chalk(
                    db,
                    substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
                );
@@ -213,14 +213,17 @@ fn array_to_chalk(db: &dyn HirDatabase, ty: Ty) -> chalk_ir::Ty<Interner> {
    chalk_ir::TyKind::Array(arg, const_).intern(&Interner)
 }
-impl ToChalk for Substs {
+impl ToChalk for Substitution {
    type Chalk = chalk_ir::Substitution<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> {
        chalk_ir::Substitution::from_iter(&Interner, self.iter().map(|ty| ty.clone().to_chalk(db)))
    }
-    fn from_chalk(db: &dyn HirDatabase, parameters: chalk_ir::Substitution<Interner>) -> Substs {
+    fn from_chalk(
+        db: &dyn HirDatabase,
+        parameters: chalk_ir::Substitution<Interner>,
+    ) -> Substitution {
        let tys = parameters
            .iter(&Interner)
            .map(|p| match p.ty(&Interner) {
@@ -228,7 +231,7 @@ impl ToChalk for Substs {
                None => unimplemented!(),
            })
            .collect();
-        Substs(tys)
+        Substitution(tys)
    }
 }
@@ -489,7 +492,7 @@ where
 pub(super) fn convert_where_clauses(
    db: &dyn HirDatabase,
    def: GenericDefId,
-    substs: &Substs,
+    substs: &Substitution,
 ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
    let generic_predicates = db.generic_predicates(def);
    let mut result = Vec::with_capacity(generic_predicates.len());
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index cbfc66ab3..2f840909c 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -180,7 +180,7 @@ fn missing_record_expr_field_fix(
    let def_id = sema.resolve_variant(record_lit)?;
    let module;
    let def_file_id;
-    let record_fields = match VariantDef::from(def_id) {
+    let record_fields = match def_id {
        VariantDef::Struct(s) => {
            module = s.module(sema.db);
            let source = s.source(sema.db)?;
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 461e11060..5ea9fc4fb 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -93,7 +93,7 @@ pub(crate) fn remove_links(markdown: &str) -> String {
    let mut cb = |_: BrokenLink| {
        let empty = InlineStr::try_from("").unwrap();
-        Some((CowStr::Inlined(empty.clone()), CowStr::Inlined(empty)))
+        Some((CowStr::Inlined(empty), CowStr::Inlined(empty)))
    };
    let doc = Parser::new_with_broken_link_callback(markdown, opts, Some(&mut cb));
    let doc = doc.filter_map(move |evt| match evt {
@@ -147,7 +147,7 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
        _ => return None,
    };
-    let ns = ItemInNs::from(target_def.clone());
+    let ns = ItemInNs::from(target_def);
    let module = definition.module(db)?;
    let krate = module.krate();
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 6986477a5..b71f4917c 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -102,7 +102,7 @@ fn extract_positioned_link_from_comment(
            None => comment_range.end(),
        }
    })?;
-    Some((def_link.to_string(), ns.clone()))
+    Some((def_link.to_string(), *ns))
 }
 fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 8d45b4875..325014622 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,6 +1,6 @@
 use either::Either;
 use hir::{
-    Adt, AsAssocItem, AssocItemContainer, GenericParam, HasAttrs, HasSource, HirDisplay, Module,
+    AsAssocItem, AssocItemContainer, GenericParam, HasAttrs, HasSource, HirDisplay, Module,
    ModuleDef, Semantics,
 };
 use ide_db::{
@@ -339,9 +339,7 @@ fn hover_for_definition(
        Definition::ModuleDef(it) => match it {
            ModuleDef::Module(it) => from_hir_fmt(db, it, mod_path),
            ModuleDef::Function(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Adt(Adt::Struct(it)) => from_hir_fmt(db, it, mod_path),
+            ModuleDef::Adt(it) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Adt(Adt::Union(it)) => from_hir_fmt(db, it, mod_path),
-            ModuleDef::Adt(Adt::Enum(it)) => from_hir_fmt(db, it, mod_path),
            ModuleDef::Variant(it) => from_hir_fmt(db, it, mod_path),
            ModuleDef::Const(it) => from_hir_fmt(db, it, mod_path),
            ModuleDef::Static(it) => from_hir_fmt(db, it, mod_path),
@@ -353,18 +351,10 @@ fn hover_for_definition(
        },
        Definition::Local(it) => hover_for_local(it, db),
        Definition::SelfType(impl_def) => {
-            impl_def.target_ty(db).as_adt().and_then(|adt| match adt {
+            impl_def.target_ty(db).as_adt().and_then(|adt| from_hir_fmt(db, adt, mod_path))
-                Adt::Struct(it) => from_hir_fmt(db, it, mod_path),
-                Adt::Union(it) => from_hir_fmt(db, it, mod_path),
-                Adt::Enum(it) => from_hir_fmt(db, it, mod_path),
-            })
        }
+        Definition::GenericParam(it) => from_hir_fmt(db, it, None),
        Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::GenericParam(it) => match it {
-            GenericParam::TypeParam(it) => Some(Markup::fenced_block(&it.display(db))),
-            GenericParam::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
-            GenericParam::ConstParam(it) => Some(Markup::fenced_block(&it.display(db))),
-        },
    };
    fn from_hir_fmt<D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index d4c367f66..d57ce4027 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -60,7 +60,7 @@ pub(super) fn ra_fixture(
        for range in inj.map_range_up(hl_range.range) {
            if let Some(range) = literal.map_range_up(range) {
                hl_range.range = range;
-                hl.add(hl_range.clone());
+                hl.add(hl_range);
            }
        }
    }
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 5b540df5c..83aa11d52 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -73,8 +73,8 @@ fn find_parent_and_path(
 ) -> Option<(Either<ast::UseTree, ast::UseTreeList>, ast::Path)> {
    return star.ancestors().find_map(|n| {
        find_use_tree_list(n.clone())
-            .and_then(|(u, p)| Some((Either::Right(u), p)))
+            .map(|(u, p)| (Either::Right(u), p))
-            .or_else(|| find_use_tree(n).and_then(|(u, p)| Some((Either::Left(u), p))))
+            .or_else(|| find_use_tree(n).map(|(u, p)| (Either::Left(u), p)))
    });
    fn find_use_tree_list(n: SyntaxNode) -> Option<(ast::UseTreeList, ast::Path)> {
diff --git a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
index 335e0ed95..596c536a7 100644
--- a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -145,11 +145,8 @@ fn insert_import(
    variant_hir_name: &Name,
 ) -> Option<()> {
    let db = ctx.db();
-    let mod_path = module.find_use_path_prefixed(
+    let mod_path =
-        db,
+        module.find_use_path_prefixed(db, *enum_module_def, ctx.config.insert_use.prefix_kind);
-        enum_module_def.clone(),
-        ctx.config.insert_use.prefix_kind,
-    );
    if let Some(mut mod_path) = mod_path {
        mod_path.pop_segment();
        mod_path.push_segment(variant_hir_name.clone());
diff --git a/crates/ide_assists/src/handlers/move_bounds.rs b/crates/ide_assists/src/handlers/move_bounds.rs
index 48efa67ed..9ad0c9816 100644
--- a/crates/ide_assists/src/handlers/move_bounds.rs
+++ b/crates/ide_assists/src/handlers/move_bounds.rs
@@ -40,9 +40,9 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
            let where_clause: ast::WhereClause = match_ast! {
                match parent {
                    ast::Fn(it) => it.get_or_create_where_clause(),
-                    // ast::Trait(it) => it.get_or_create_where_clause(),
+                    ast::Trait(it) => it.get_or_create_where_clause(),
                    ast::Impl(it) => it.get_or_create_where_clause(),
-                    // ast::Enum(it) => it.get_or_create_where_clause(),
+                    ast::Enum(it) => it.get_or_create_where_clause(),
                    ast::Struct(it) => it.get_or_create_where_clause(),
                    _ => return,
                }
@@ -82,12 +82,8 @@ mod tests {
    fn move_bounds_to_where_clause_fn() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"fn foo<T: u32, $0F: FnOnce(T) -> T>() {}"#,
-            fn foo<T: u32, $0F: FnOnce(T) -> T>() {}
+            r#"fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}"#,
-            "#,
-            r#"
-            fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
-            "#,
        );
    }
@@ -95,12 +91,8 @@ mod tests {
    fn move_bounds_to_where_clause_impl() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"impl<U: u32, $0T> A<U, T> {}"#,
-            impl<U: u32, $0T> A<U, T> {}
+            r#"impl<U, T> A<U, T> where U: u32 {}"#,
-            "#,
-            r#"
-            impl<U, T> A<U, T> where U: u32 {}
-            "#,
        );
    }
@@ -108,12 +100,8 @@ mod tests {
    fn move_bounds_to_where_clause_struct() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"struct A<$0T: Iterator<Item = u32>> {}"#,
-            struct A<$0T: Iterator<Item = u32>> {}
+            r#"struct A<T> where T: Iterator<Item = u32> {}"#,
-            "#,
-            r#"
-            struct A<T> where T: Iterator<Item = u32> {}
-            "#,
        );
    }
@@ -121,12 +109,8 @@ mod tests {
    fn move_bounds_to_where_clause_tuple_struct() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"struct Pair<$0T: u32>(T, T);"#,
-            struct Pair<$0T: u32>(T, T);
+            r#"struct Pair<T>(T, T) where T: u32;"#,
-            "#,
-            r#"
-            struct Pair<T>(T, T) where T: u32;
-            "#,
        );
    }
 }
diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index 3b582ed07..09882c4f3 100644
--- a/crates/ide_completion/src/completions.rs
+++ b/crates/ide_completion/src/completions.rs
@@ -56,7 +56,7 @@ impl Builder {
 impl Completions {
    pub(crate) fn add(&mut self, item: CompletionItem) {
-        self.buf.push(item.into())
+        self.buf.push(item)
    }
    pub(crate) fn add_all<I>(&mut self, items: I)
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index 46cef58f0..476eecff0 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -26,11 +26,11 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
        let add_resolution = match &res {
            hir::ScopeDef::ModuleDef(def) => match def {
                hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-                    acc.add_struct_pat(ctx, strukt.clone(), Some(name.clone()));
+                    acc.add_struct_pat(ctx, *strukt, Some(name.clone()));
                    true
                }
                hir::ModuleDef::Variant(variant) if !ctx.is_irrefutable_pat_binding => {
-                    acc.add_variant_pat(ctx, variant.clone(), Some(name.clone()));
+                    acc.add_variant_pat(ctx, *variant, Some(name.clone()));
                    true
                }
                hir::ModuleDef::Adt(hir::Adt::Enum(..))
diff --git a/crates/ide_completion/src/completions/postfix/format_like.rs b/crates/ide_completion/src/completions/postfix/format_like.rs
index cee4eec10..3f1c6730b 100644
--- a/crates/ide_completion/src/completions/postfix/format_like.rs
+++ b/crates/ide_completion/src/completions/postfix/format_like.rs
@@ -89,7 +89,7 @@ enum State {
 impl FormatStrParser {
    pub(crate) fn new(input: String) -> Self {
        Self {
-            input: input.into(),
+            input: input,
            output: String::new(),
            extracted_expressions: Vec::new(),
            state: State::NotExpr,
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 4e4923e0d..12921e12b 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -81,7 +81,7 @@ impl<'a> RenderContext<'a> {
    }
    fn snippet_cap(&self) -> Option<SnippetCap> {
-        self.completion.config.snippet_cap.clone()
+        self.completion.config.snippet_cap
    }
    fn db(&self) -> &'a RootDatabase {
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index f86e5ce93..75167ff39 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -181,7 +181,7 @@ impl NameClass {
                },
                ast::SelfParam(it) => {
                    let def = sema.to_def(&it)?;
-                    Some(NameClass::Definition(Definition::Local(def.into())))
+                    Some(NameClass::Definition(Definition::Local(def)))
                },
                ast::RecordField(it) => {
                    let field: hir::Field = sema.to_def(&it)?;
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index df66d8ea0..9e0cb91c3 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -80,7 +80,7 @@ impl ImportScope {
            })
            .last()
            .map(|last_inner_element| {
-                (InsertPosition::After(last_inner_element.into()), AddBlankLine::BeforeTwice)
+                (InsertPosition::After(last_inner_element), AddBlankLine::BeforeTwice)
            })
            .unwrap_or_else(|| self.first_insert_pos())
    }
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index f56221a6c..324817cd0 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -161,15 +161,9 @@ impl Definition {
        if let Definition::Local(var) = self {
            let range = match var.parent(db) {
-                DefWithBody::Function(f) => {
+                DefWithBody::Function(f) => f.source(db).map(|src| src.value.syntax().text_range()),
-                    f.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                DefWithBody::Const(c) => c.source(db).map(|src| src.value.syntax().text_range()),
-                }
+                DefWithBody::Static(s) => s.source(db).map(|src| src.value.syntax().text_range()),
-                DefWithBody::Const(c) => {
-                    c.source(db).and_then(|src| Some(src.value.syntax().text_range()))
-                }
-                DefWithBody::Static(s) => {
-                    s.source(db).and_then(|src| Some(src.value.syntax().text_range()))
-                }
            };
            let mut res = FxHashMap::default();
            res.insert(file_id, range);
@@ -179,33 +173,29 @@ impl Definition {
        if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {
            let range = match param.parent(db) {
                hir::GenericDef::Function(it) => {
-                    it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                    it.source(db).map(|src| src.value.syntax().text_range())
                }
                hir::GenericDef::Adt(it) => match it {
                    hir::Adt::Struct(it) => {
-                        it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                        it.source(db).map(|src| src.value.syntax().text_range())
-                    }
-                    hir::Adt::Union(it) => {
-                        it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
-                    }
-                    hir::Adt::Enum(it) => {
-                        it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
                    }
+                    hir::Adt::Union(it) => it.source(db).map(|src| src.value.syntax().text_range()),
+                    hir::Adt::Enum(it) => it.source(db).map(|src| src.value.syntax().text_range()),
                },
                hir::GenericDef::Trait(it) => {
-                    it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                    it.source(db).map(|src| src.value.syntax().text_range())
                }
                hir::GenericDef::TypeAlias(it) => {
-                    it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                    it.source(db).map(|src| src.value.syntax().text_range())
                }
                hir::GenericDef::Impl(it) => {
-                    it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                    it.source(db).map(|src| src.value.syntax().text_range())
                }
                hir::GenericDef::Variant(it) => {
-                    it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                    it.source(db).map(|src| src.value.syntax().text_range())
                }
                hir::GenericDef::Const(it) => {
-                    it.source(db).and_then(|src| Some(src.value.syntax().text_range()))
+                    it.source(db).map(|src| src.value.syntax().text_range())
                }
            };
            let mut res = FxHashMap::default();
diff --git a/crates/ide_ssr/src/lib.rs b/crates/ide_ssr/src/lib.rs
index 00585f448..47434f4af 100644
--- a/crates/ide_ssr/src/lib.rs
+++ b/crates/ide_ssr/src/lib.rs
@@ -139,11 +139,8 @@ impl<'db> MatchFinder<'db> {
    pub fn at_first_file(db: &'db ide_db::RootDatabase) -> Result<MatchFinder<'db>, SsrError> {
        use ide_db::base_db::SourceDatabaseExt;
        use ide_db::symbol_index::SymbolsDatabase;
-        if let Some(first_file_id) = db
+        if let Some(first_file_id) =
-            .local_roots()
+            db.local_roots().iter().next().and_then(|root| db.source_root(*root).iter().next())
-            .iter()
-            .next()
-            .and_then(|root| db.source_root(root.clone()).iter().next())
        {
            Ok(MatchFinder::in_context(
                db,
diff --git a/crates/ide_ssr/src/matching.rs b/crates/ide_ssr/src/matching.rs
index e1adb381e..b3072fb9f 100644
--- a/crates/ide_ssr/src/matching.rs
+++ b/crates/ide_ssr/src/matching.rs
@@ -127,7 +127,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
        restrict_range: &Option<FileRange>,
        sema: &'sema Semantics<'db, ide_db::RootDatabase>,
    ) -> Result<Match, MatchFailed> {
-        let match_state = Matcher { sema, restrict_range: restrict_range.clone(), rule };
+        let match_state = Matcher { sema, restrict_range: *restrict_range, rule };
        // First pass at matching, where we check that node types and idents match.
        match_state.attempt_match_node(&mut Phase::First, &rule.pattern.node, code)?;
        match_state.validate_range(&sema.original_range(code))?;
diff --git a/crates/mbe/src/benchmark.rs b/crates/mbe/src/benchmark.rs
index 503ad1355..ba814a2e1 100644
--- a/crates/mbe/src/benchmark.rs
+++ b/crates/mbe/src/benchmark.rs
@@ -120,7 +120,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, MacroRules>) -> Vec<(String, tt
                Some("pat") => parent.token_trees.push(make_ident("foo")),
                Some("path") => parent.token_trees.push(make_ident("foo")),
                Some("literal") => parent.token_trees.push(make_literal("1")),
-                Some("expr") => parent.token_trees.push(make_ident("foo").into()),
+                Some("expr") => parent.token_trees.push(make_ident("foo")),
                Some("lifetime") => {
                    parent.token_trees.push(make_punct('\''));
                    parent.token_trees.push(make_ident("a"));
@@ -157,17 +157,15 @@ fn invocation_fixtures(rules: &FxHashMap<String, MacroRules>) -> Vec<(String, tt
                    if i + 1 != cnt {
                        if let Some(sep) = separator {
                            match sep {
-                                Separator::Literal(it) => parent
+                                Separator::Literal(it) => {
-                                    .token_trees
+                                    parent.token_trees.push(tt::Leaf::Literal(it.clone()).into())
-                                    .push(tt::Leaf::Literal(it.clone().into()).into()),
+                                }
-                                Separator::Ident(it) => parent
+                                Separator::Ident(it) => {
-                                    .token_trees
+                                    parent.token_trees.push(tt::Leaf::Ident(it.clone()).into())
-                                    .push(tt::Leaf::Ident(it.clone().into()).into()),
+                                }
                                Separator::Puncts(puncts) => {
                                    for it in puncts {
-                                        parent
+                                        parent.token_trees.push(tt::Leaf::Punct(*it).into())
-                                            .token_trees
-                                            .push(tt::Leaf::Punct(it.clone().into()).into())
                                    }
                                }
                            };
@@ -176,8 +174,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, MacroRules>) -> Vec<(String, tt
                }
            }
            Op::Subtree { tokens, delimiter } => {
-                let mut subtree =
+                let mut subtree = tt::Subtree { delimiter: *delimiter, token_trees: Vec::new() };
-                    tt::Subtree { delimiter: delimiter.clone(), token_trees: Vec::new() };
                tokens.iter().for_each(|it| {
                    collect_from_op(it, &mut subtree, seed);
                });
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 2c69e8968..b6782b4ba 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -540,7 +540,7 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
    let mut src = TtIter::new(src);
    let mut stack: SmallVec<[TtIter; 1]> = SmallVec::new();
    let mut res = Match::default();
-    let mut error_reover_item = None;
+    let mut error_recover_item = None;
    let mut bindings_builder = BindingsBuilder::default();
@@ -579,9 +579,9 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
        stdx::always!(cur_items.is_empty());
        if error_items.len() > 0 {
-            error_reover_item = error_items.pop().map(|it| it.bindings);
+            error_recover_item = error_items.pop().map(|it| it.bindings);
        } else if eof_items.len() > 0 {
-            error_reover_item = Some(eof_items[0].bindings.clone());
+            error_recover_item = Some(eof_items[0].bindings.clone());
        }
        // We need to do some post processing after the `match_loop_inner`.
@@ -594,8 +594,8 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
                res.bindings = bindings_builder.build(&eof_items[0].bindings);
            } else {
                // Error recovery
-                if error_reover_item.is_some() {
+                if let Some(item) = error_recover_item {
-                    res.bindings = bindings_builder.build(&error_reover_item.unwrap());
+                    res.bindings = bindings_builder.build(&item);
                }
                res.add_err(ExpandError::UnexpectedToken);
            }
@@ -618,7 +618,7 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
            }
            res.add_err(err!("leftover tokens"));
-            if let Some(error_reover_item) = error_reover_item {
+            if let Some(error_reover_item) = error_recover_item {
                res.bindings = bindings_builder.build(&error_reover_item);
            }
            return res;
@@ -722,7 +722,7 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
                    input
                        .expect_literal()
                        .map(|literal| {
-                            let lit = tt::Leaf::from(literal.clone());
+                            let lit = literal.clone();
                            match neg {
                                None => Some(lit.into()),
                                Some(neg) => Some(tt::TokenTree::Subtree(tt::Subtree {
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index 8671322e1..7b5b8ec16 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -262,7 +262,7 @@ fn parse_repeat(src: &mut TtIter) -> Result<(Option<Separator>, RepeatKind), Par
                                if puncts.len() == 3 {
                                    return Err(ParseError::InvalidRepeat);
                                }
-                                puncts.push(punct.clone())
+                                puncts.push(*punct)
                            }
                            _ => return Err(ParseError::InvalidRepeat),
                        }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index b715ebfc4..85163c4b3 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -130,7 +130,7 @@ pub fn parse_exprs_with_sep(tt: &tt::Subtree, sep: char) -> Vec<tt::Subtree> {
        res.push(match expanded.value {
            None => break,
            Some(tt @ tt::TokenTree::Leaf(_)) => {
-                tt::Subtree { delimiter: None, token_trees: vec![tt.into()] }
+                tt::Subtree { delimiter: None, token_trees: vec![tt] }
            }
            Some(tt::TokenTree::Subtree(tt)) => tt,
        });
@@ -727,7 +727,7 @@ impl<'a> TreeSink for TtTreeSink<'a> {
            // Note: We always assume the semi-colon would be the last token in
            // other parts of RA such that we don't add whitespace here.
            if curr.spacing == tt::Spacing::Alone && curr.char != ';' {
-                self.inner.token(WHITESPACE, " ".into());
+                self.inner.token(WHITESPACE, " ");
                self.text_pos += TextSize::of(' ');
            }
        }
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index eca0bcc18..25c374b9b 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -35,7 +35,7 @@ mod rule_parsing {
    fn test_invalid_arms() {
        fn check(macro_body: &str, err: ParseError) {
            let m = parse_macro_arm(macro_body);
-            assert_eq!(m, Err(err.into()));
+            assert_eq!(m, Err(err));
        }
        check("invalid", ParseError::Expected("expected subtree".into()));
diff --git a/crates/proc_macro_api/src/process.rs b/crates/proc_macro_api/src/process.rs
index 3ce851fe8..30bb1b687 100644
--- a/crates/proc_macro_api/src/process.rs
+++ b/crates/proc_macro_api/src/process.rs
@@ -154,5 +154,5 @@ fn send_request(
    req: Request,
 ) -> io::Result<Option<Response>> {
    req.write(&mut writer)?;
-    Ok(Response::read(&mut reader)?)
+    Response::read(&mut reader)
 }
diff --git a/crates/proc_macro_api/src/rpc.rs b/crates/proc_macro_api/src/rpc.rs
index 64cfdafc5..9a68e2cc5 100644
--- a/crates/proc_macro_api/src/rpc.rs
+++ b/crates/proc_macro_api/src/rpc.rs
@@ -236,13 +236,10 @@ mod tests {
        subtree
            .token_trees
            .push(TokenTree::Leaf(Ident { text: "Foo".into(), id: TokenId(1) }.into()));
-        subtree.token_trees.push(TokenTree::Subtree(
+        subtree.token_trees.push(TokenTree::Subtree(Subtree {
-            Subtree {
+            delimiter: Some(Delimiter { id: TokenId(2), kind: DelimiterKind::Brace }),
-                delimiter: Some(Delimiter { id: TokenId(2), kind: DelimiterKind::Brace }),
+            token_trees: vec![],
-                token_trees: vec![],
+        }));
-            }
-            .into(),
-        ));
        subtree
    }
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 0ad832c0e..76994de71 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -161,7 +161,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
        return Vec::new();
    }
-    let severity = diagnostic_severity(config, rd.level.clone(), rd.code.clone());
+    let severity = diagnostic_severity(config, rd.level, rd.code.clone());
    let mut source = String::from("rustc");
    let mut code = rd.code.as_ref().map(|c| c.code.clone());
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 6fb7da79c..b6f484e51 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -1134,7 +1134,7 @@ pub(crate) fn handle_code_lens_resolve(
 ) -> Result<CodeLens> {
    let annotation = from_proto::annotation(&snap, code_lens)?;
-    Ok(to_proto::code_lens(&snap, snap.analysis.resolve_annotation(annotation)?)?)
+    to_proto::code_lens(&snap, snap.analysis.resolve_annotation(annotation)?)
 }
 pub(crate) fn handle_document_highlight(
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 3ca7f8040..2ac487632 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -36,7 +36,7 @@ impl Progress {
 impl GlobalState {
    pub(crate) fn show_message(&mut self, typ: lsp_types::MessageType, message: String) {
-        let message = message.into();
+        let message = message;
        self.send_notification::<lsp_types::notification::ShowMessage>(
            lsp_types::ShowMessageParams { typ, message },
        )
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 70eaae5e8..c63fe2915 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -287,7 +287,7 @@ pub(crate) fn signature_help(
            let params = call_info
                .parameter_ranges()
                .iter()
-                .map(|it| [u32::from(it.start()).into(), u32::from(it.end()).into()])
+                .map(|it| [u32::from(it.start()), u32::from(it.end())])
                .map(|label_offsets| lsp_types::ParameterInformation {
                    label: lsp_types::ParameterLabel::LabelOffsets(label_offsets),
                    documentation: None,
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 0b3b76d4a..64fac13a7 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -479,7 +479,7 @@ impl ast::MatchArmList {
            Some(t) => t,
            None => return self.clone(),
        };
-        let position = InsertPosition::Before(r_curly.into());
+        let position = InsertPosition::Before(r_curly);
        let arm_ws = tokens::WsBuilder::new("    ");
        let match_indent = &leading_indent(self.syntax()).unwrap_or_default();
        let match_ws = tokens::WsBuilder::new(&format!("\n{}", match_indent));
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index 06cde591d..449b058fb 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -8,7 +8,7 @@ use parser::T;
 use crate::{
    ast,
    ted::{self, Position},
-    AstNode, Direction, SyntaxKind,
+    AstNode, Direction, SyntaxElement,
 };
 use super::NameOwner;
@@ -36,8 +36,8 @@ impl GenericParamsOwnerEdit for ast::Fn {
 impl GenericParamsOwnerEdit for ast::Impl {
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
-            let position = if let Some(ty) = self.self_ty() {
+            let position = if let Some(items) = self.assoc_item_list() {
-                Position::after(ty.syntax().clone())
+                Position::before(items.syntax().clone())
            } else {
                Position::last_child_of(self.syntax().clone())
            };
@@ -46,6 +46,21 @@ impl GenericParamsOwnerEdit for ast::Impl {
        self.where_clause().unwrap()
    }
 }
+impl GenericParamsOwnerEdit for ast::Trait {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let position = if let Some(items) = self.assoc_item_list() {
+                Position::before(items.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position)
+        }
+        self.where_clause().unwrap()
+    }
+}
 impl GenericParamsOwnerEdit for ast::Struct {
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
@@ -68,26 +83,35 @@ impl GenericParamsOwnerEdit for ast::Struct {
    }
 }
+impl GenericParamsOwnerEdit for ast::Enum {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let position = if let Some(gpl) = self.generic_param_list() {
+                Position::after(gpl.syntax().clone())
+            } else if let Some(name) = self.name() {
+                Position::after(name.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position)
+        }
+        self.where_clause().unwrap()
+    }
+}
 fn create_where_clause(position: Position) {
-    let elements = vec![
+    let where_clause: SyntaxElement =
-        make::tokens::single_space().into(),
+        make::where_clause(empty()).clone_for_update().syntax().clone().into();
-        make::where_clause(empty()).clone_for_update().syntax().clone().into(),
+    ted::insert(position, where_clause);
-    ];
-    ted::insert_all(position, elements);
 }
 impl ast::WhereClause {
    pub fn add_predicate(&self, predicate: ast::WherePred) {
        if let Some(pred) = self.predicates().last() {
            if !pred.syntax().siblings_with_tokens(Direction::Next).any(|it| it.kind() == T![,]) {
-                ted::append_child(self.syntax().clone(), make::token(T![,]));
+                ted::append_child_raw(self.syntax().clone(), make::token(T![,]));
            }
        }
-        if self.syntax().children_with_tokens().last().map(|it| it.kind())
-            != Some(SyntaxKind::WHITESPACE)
-        {
-            ted::append_child(self.syntax().clone(), make::tokens::single_space());
-        }
        ted::append_child(self.syntax().clone(), predicate.syntax().clone())
    }
 }
diff --git a/crates/syntax/src/ted.rs b/crates/syntax/src/ted.rs
index 8d6175ed9..442dfa14a 100644
--- a/crates/syntax/src/ted.rs
+++ b/crates/syntax/src/ted.rs
@@ -1,8 +1,12 @@
-//! Primitive tree editor, ed for trees
+//! Primitive tree editor, ed for trees.
-#![allow(unused)]
+//!
+//! The `_raw`-suffixed functions insert elements as is, unsuffixed versions fix
+//! up elements around the edges.
 use std::ops::RangeInclusive;
-use crate::{SyntaxElement, SyntaxNode};
+use parser::T;
+use crate::{ast::make, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken};
 #[derive(Debug)]
 pub struct Position {
@@ -45,7 +49,23 @@ impl Position {
 pub fn insert(position: Position, elem: impl Into<SyntaxElement>) {
    insert_all(position, vec![elem.into()])
 }
-pub fn insert_all(position: Position, elements: Vec<SyntaxElement>) {
+pub fn insert_raw(position: Position, elem: impl Into<SyntaxElement>) {
+    insert_all_raw(position, vec![elem.into()])
+}
+pub fn insert_all(position: Position, mut elements: Vec<SyntaxElement>) {
+    if let Some(first) = elements.first() {
+        if let Some(ws) = ws_before(&position, first) {
+            elements.insert(0, ws.into())
+        }
+    }
+    if let Some(last) = elements.last() {
+        if let Some(ws) = ws_after(&position, last) {
+            elements.push(ws.into())
+        }
+    }
+    insert_all_raw(position, elements)
+}
+pub fn insert_all_raw(position: Position, elements: Vec<SyntaxElement>) {
    let (parent, index) = match position.repr {
        PositionRepr::FirstChild(parent) => (parent, 0),
        PositionRepr::After(child) => (child.parent().unwrap(), child.index() + 1),
@@ -76,3 +96,31 @@ pub fn append_child(node: impl Into<SyntaxNode>, child: impl Into<SyntaxElement>
    let position = Position::last_child_of(node);
    insert(position, child)
 }
+pub fn append_child_raw(node: impl Into<SyntaxNode>, child: impl Into<SyntaxElement>) {
+    let position = Position::last_child_of(node);
+    insert_raw(position, child)
+}
+fn ws_before(position: &Position, new: &SyntaxElement) -> Option<SyntaxToken> {
+    let prev = match &position.repr {
+        PositionRepr::FirstChild(_) => return None,
+        PositionRepr::After(it) => it,
+    };
+    ws_between(prev, new)
+}
+fn ws_after(position: &Position, new: &SyntaxElement) -> Option<SyntaxToken> {
+    let next = match &position.repr {
+        PositionRepr::FirstChild(parent) => parent.first_child_or_token()?,
+        PositionRepr::After(sibling) => sibling.next_sibling_or_token()?,
+    };
+    ws_between(new, &next)
+}
+fn ws_between(left: &SyntaxElement, right: &SyntaxElement) -> Option<SyntaxToken> {
+    if left.kind() == SyntaxKind::WHITESPACE || right.kind() == SyntaxKind::WHITESPACE {
+        return None;
+    }
+    if right.kind() == T![;] || right.kind() == T![,] {
+        return None;
+    }
+    Some(make::tokens::single_space())
+}