63 files changed, 2238 insertions, 1908 deletions
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index 1d19c7886..2a1a21b28 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -12,9 +12,9 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.5.0"
 log = "0.4.8"
-cargo_metadata = "0.12.2"
+cargo_metadata = "0.13"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
 toolchain = { path = "../toolchain", version = "0.0.0" }
-stdx = { path = "../stdx", version = "0.0.0"  }
+stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index e04208006..e2a59497a 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -194,7 +194,7 @@ impl FlycheckActor {
                    cargo_metadata::Message::BuildScriptExecuted(_)
                    | cargo_metadata::Message::BuildFinished(_)
                    | cargo_metadata::Message::TextLine(_)
-                    | cargo_metadata::Message::Unknown => {}
+                    | _ => {}
                },
            }
        }
@@ -329,8 +329,7 @@ impl CargoActor {
            // Skip certain kinds of messages to only spend time on what's useful
            match &message {
                cargo_metadata::Message::CompilerArtifact(artifact) if artifact.fresh => (),
-                cargo_metadata::Message::BuildScriptExecuted(_)
+                cargo_metadata::Message::BuildScriptExecuted(_) => (),
-                | cargo_metadata::Message::Unknown => (),
                _ => self.sender.send(message).unwrap(),
            }
        }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index b3218833d..fc1a74641 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -14,7 +14,7 @@ use hir_def::{
    per_ns::PerNs,
    resolver::{HasResolver, Resolver},
    src::HasSource as _,
-    type_ref::{Mutability, TypeRef},
+    type_ref::TypeRef,
    AdtId, AssocContainerId, AssocItemId, AssocItemLoc, AttrDefId, ConstId, ConstParamId,
    DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId, LifetimeParamId,
    LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
@@ -31,9 +31,9 @@ use hir_ty::{
    display::{write_bounds_like_dyn_trait_with_prefix, HirDisplayError, HirFormatter},
    method_resolution,
    traits::{FnTrait, Solution, SolutionVariables},
-    ApplicationTy, BoundVar, CallableDefId, Canonical, DebruijnIndex, FnSig, GenericPredicate,
+    AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
-    InEnvironment, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, Ty,
+    InEnvironment, Mutability, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs,
-    TyDefId, TyKind, TypeCtor,
+    TraitEnvironment, Ty, TyDefId, TyVariableKind,
 };
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
@@ -836,7 +836,7 @@ pub enum Access {
 impl From<Mutability> for Access {
    fn from(mutability: Mutability) -> Access {
        match mutability {
-            Mutability::Shared => Access::Shared,
+            Mutability::Not => Access::Shared,
            Mutability::Mut => Access::Exclusive,
        }
    }
@@ -865,7 +865,10 @@ impl SelfParam {
            .params
            .first()
            .map(|param| match *param {
-                TypeRef::Reference(.., mutability) => mutability.into(),
+                TypeRef::Reference(.., mutability) => match mutability {
+                    hir_def::type_ref::Mutability::Shared => Access::Shared,
+                    hir_def::type_ref::Mutability::Mut => Access::Exclusive,
+                },
                _ => Access::Owned,
            })
            .unwrap_or(Access::Owned)
@@ -1547,25 +1550,19 @@ impl Type {
    }
    pub fn is_unit(&self) -> bool {
-        matches!(
+        matches!(self.ty.value, Ty::Tuple(0, ..))
-            self.ty.value,
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Tuple { cardinality: 0 }, .. })
-        )
    }
    pub fn is_bool(&self) -> bool {
-        matches!(self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. }))
+        matches!(self.ty.value, Ty::Scalar(Scalar::Bool))
    }
    pub fn is_mutable_reference(&self) -> bool {
-        matches!(
+        matches!(self.ty.value, Ty::Ref(Mutability::Mut, ..))
-            self.ty.value,
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(Mutability::Mut), .. })
-        )
    }
    pub fn remove_ref(&self) -> Option<Type> {
-        if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(_), .. }) = self.ty.value {
+        if let Ty::Ref(.., substs) = &self.ty.value {
-            self.ty.value.substs().map(|substs| self.derived(substs[0].clone()))
+            Some(self.derived(substs[0].clone()))
        } else {
            None
        }
@@ -1654,14 +1651,14 @@ impl Type {
            .build();
        let predicate = ProjectionPredicate {
            projection_ty: ProjectionTy { associated_ty: alias.id, parameters: subst },
-            ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)),
+            ty: Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)),
        };
        let goal = Canonical {
            value: InEnvironment::new(
                self.ty.environment.clone(),
                Obligation::Projection(predicate),
            ),
-            kinds: Arc::new([TyKind::General]),
+            kinds: Arc::new([TyVariableKind::General]),
        };
        match db.trait_solve(self.krate, goal)? {
@@ -1685,7 +1682,7 @@ impl Type {
    pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
        let def = match self.ty.value {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(def), parameters: _ }) => Some(def),
+            Ty::FnDef(def, _) => Some(def),
            _ => None,
        };
@@ -1694,20 +1691,16 @@ impl Type {
    }
    pub fn is_closure(&self) -> bool {
-        matches!(&self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Closure { .. }, .. }))
+        matches!(&self.ty.value, Ty::Closure { .. })
    }
    pub fn is_fn(&self) -> bool {
-        matches!(
+        matches!(&self.ty.value, Ty::FnDef(..) | Ty::Function { .. })
-            &self.ty.value,
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(..), .. })
-                | Ty::Apply(ApplicationTy { ctor: TypeCtor::FnPtr { .. }, .. })
-        )
    }
    pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
        let adt_id = match self.ty.value {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Adt(adt_id), .. }) => adt_id,
+            Ty::Adt(adt_id, ..) => adt_id,
            _ => return false,
        };
@@ -1719,7 +1712,7 @@ impl Type {
    }
    pub fn is_raw_ptr(&self) -> bool {
-        matches!(&self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::RawPtr(..), .. }))
+        matches!(&self.ty.value, Ty::Raw(..))
    }
    pub fn contains_unknown(&self) -> bool {
@@ -1728,44 +1721,34 @@ impl Type {
        fn go(ty: &Ty) -> bool {
            match ty {
                Ty::Unknown => true,
-                Ty::Apply(a_ty) => a_ty.parameters.iter().any(go),
+                _ => ty.substs().map_or(false, |substs| substs.iter().any(go)),
-                _ => false,
            }
        }
    }
    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
-        if let Ty::Apply(a_ty) = &self.ty.value {
+        let (variant_id, substs) = match self.ty.value {
-            let variant_id = match a_ty.ctor {
+            Ty::Adt(AdtId::StructId(s), ref substs) => (s.into(), substs),
-                TypeCtor::Adt(AdtId::StructId(s)) => s.into(),
+            Ty::Adt(AdtId::UnionId(u), ref substs) => (u.into(), substs),
-                TypeCtor::Adt(AdtId::UnionId(u)) => u.into(),
+            _ => return Vec::new(),
-                _ => return Vec::new(),
-            };
-            return db
-                .field_types(variant_id)
-                .iter()
-                .map(|(local_id, ty)| {
-                    let def = Field { parent: variant_id.into(), id: local_id };
-                    let ty = ty.clone().subst(&a_ty.parameters);
-                    (def, self.derived(ty))
-                })
-                .collect();
        };
-        Vec::new()
+        db.field_types(variant_id)
+            .iter()
+            .map(|(local_id, ty)| {
+                let def = Field { parent: variant_id.into(), id: local_id };
+                let ty = ty.clone().subst(substs);
+                (def, self.derived(ty))
+            })
+            .collect()
    }
    pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
-        let mut res = Vec::new();
+        if let Ty::Tuple(_, substs) = &self.ty.value {
-        if let Ty::Apply(a_ty) = &self.ty.value {
+            substs.iter().map(|ty| self.derived(ty.clone())).collect()
-            if let TypeCtor::Tuple { .. } = a_ty.ctor {
+        } else {
-                for ty in a_ty.parameters.iter() {
+            Vec::new()
-                    let ty = ty.clone();
+        }
-                    res.push(self.derived(ty));
-                }
-            }
-        };
-        res
    }
    pub fn autoderef<'a>(&'a self, db: &'a dyn HirDatabase) -> impl Iterator<Item = Type> + 'a {
@@ -1802,15 +1785,13 @@ impl Type {
    }
    pub fn type_parameters(&self) -> impl Iterator<Item = Type> + '_ {
-        let ty = self.ty.value.strip_references();
+        self.ty
-        let substs = match ty {
+            .value
-            Ty::Apply(apply_ty) => &apply_ty.parameters,
+            .strip_references()
-            Ty::Opaque(opaque_ty) => &opaque_ty.parameters,
+            .substs()
-            _ => return Either::Left(iter::empty()),
+            .into_iter()
-        };
+            .flat_map(|substs| substs.iter())
+            .map(move |ty| self.derived(ty.clone()))
-        let iter = substs.iter().map(move |ty| self.derived(ty.clone()));
-        Either::Right(iter)
    }
    pub fn iterate_method_candidates<T>(
@@ -1900,17 +1881,8 @@ impl Type {
    // FIXME: provide required accessors such that it becomes implementable from outside.
    pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
-        match (&self.ty.value, &other.ty.value) {
+        let rref = other.remove_ref();
-            (Ty::Apply(a_original_ty), Ty::Apply(ApplicationTy { ctor, parameters })) => match ctor
+        self.ty.value.equals_ctor(rref.as_ref().map_or(&other.ty.value, |it| &it.ty.value))
-            {
-                TypeCtor::Ref(..) => match parameters.as_single() {
-                    Ty::Apply(a_ty) => a_original_ty.ctor == a_ty.ctor,
-                    _ => false,
-                },
-                _ => a_original_ty.ctor == *ctor,
-            },
-            _ => false,
-        }
    }
    fn derived(&self, ty: Ty) -> Type {
@@ -1955,28 +1927,20 @@ impl Type {
        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
            let ty = type_.ty.value.strip_references();
            match ty {
-                Ty::Apply(ApplicationTy { ctor, parameters }) => {
+                Ty::Adt(..) => {
-                    match ctor {
+                    cb(type_.derived(ty.clone()));
-                        TypeCtor::Adt(_) => {
+                }
-                            cb(type_.derived(ty.clone()));
+                Ty::AssociatedType(..) => {
-                        }
+                    if let Some(_) = ty.associated_type_parent_trait(db) {
-                        TypeCtor::AssociatedType(_) => {
+                        cb(type_.derived(ty.clone()));
-                            if let Some(_) = ty.associated_type_parent_trait(db) {
-                                cb(type_.derived(ty.clone()));
-                            }
-                        }
-                        TypeCtor::OpaqueType(..) => {
-                            if let Some(bounds) = ty.impl_trait_bounds(db) {
-                                walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
-                            }
-                        }
-                        _ => (),
                    }
-                    // adt params, tuples, etc...
-                    walk_substs(db, type_, parameters, cb);
                }
-                Ty::Opaque(opaque_ty) => {
+                Ty::OpaqueType(..) => {
+                    if let Some(bounds) = ty.impl_trait_bounds(db) {
+                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
+                    }
+                }
+                Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
                    if let Some(bounds) = ty.impl_trait_bounds(db) {
                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
                    }
@@ -1992,7 +1956,10 @@ impl Type {
                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
                }
-                _ => (),
+                _ => {}
+            }
+            if let Some(substs) = ty.substs() {
+                walk_substs(db, type_, &substs, cb);
            }
        }
@@ -2010,7 +1977,7 @@ impl HirDisplay for Type {
 #[derive(Debug)]
 pub struct Callable {
    ty: Type,
-    sig: FnSig,
+    sig: CallableSig,
    def: Option<CallableDefId>,
    pub(crate) is_bound_method: bool,
 }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index dc21f6051..64ce4add1 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, Ty,
+    InferenceResult, Substs,
 };
 use syntax::{
    ast::{self, AstNode},
@@ -299,14 +299,11 @@ impl SourceAnalyzer {
        let infer = self.infer.as_ref()?;
        let expr_id = self.expr_id(db, &literal.clone().into())?;
-        let substs = match &infer.type_of_expr[expr_id] {
+        let substs = infer.type_of_expr[expr_id].substs()?;
-            Ty::Apply(a_ty) => &a_ty.parameters,
-            _ => return None,
-        };
        let (variant, missing_fields, _exhaustive) =
            record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
-        let res = self.missing_fields(db, krate, substs, variant, missing_fields);
+        let res = self.missing_fields(db, krate, &substs, variant, missing_fields);
        Some(res)
    }
@@ -320,14 +317,11 @@ impl SourceAnalyzer {
        let infer = self.infer.as_ref()?;
        let pat_id = self.pat_id(&pattern.clone().into())?;
-        let substs = match &infer.type_of_pat[pat_id] {
+        let substs = infer.type_of_pat[pat_id].substs()?;
-            Ty::Apply(a_ty) => &a_ty.parameters,
-            _ => return None,
-        };
        let (variant, missing_fields, _exhaustive) =
            record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
-        let res = self.missing_fields(db, krate, substs, variant, missing_fields);
+        let res = self.missing_fields(db, krate, &substs, variant, missing_fields);
        Some(res)
    }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index c18001e15..40beb2f7a 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -24,7 +24,7 @@ use test_utils::mark;
 use crate::{
    adt::StructKind,
    body::{Body, BodySourceMap, Expander, LabelSource, PatPtr, SyntheticSyntax},
-    builtin_type::{BuiltinFloat, BuiltinInt},
+    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
    db::DefDatabase,
    diagnostics::{InactiveCode, MacroError, UnresolvedProcMacro},
    expr::{
@@ -1065,11 +1065,16 @@ impl From<ast::LiteralKind> for Literal {
    fn from(ast_lit_kind: ast::LiteralKind) -> Self {
        match ast_lit_kind {
            LiteralKind::IntNumber(lit) => {
-                if let Some(float_suffix) = lit.suffix().and_then(BuiltinFloat::from_suffix) {
+                if let builtin @ Some(_) = lit.suffix().and_then(BuiltinFloat::from_suffix) {
-                    return Literal::Float(Default::default(), Some(float_suffix));
+                    return Literal::Float(Default::default(), builtin);
+                } else if let builtin @ Some(_) =
+                    lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it))
+                {
+                    Literal::Int(Default::default(), builtin)
+                } else {
+                    let builtin = lit.suffix().and_then(|it| BuiltinUint::from_suffix(&it));
+                    Literal::Uint(Default::default(), builtin)
                }
-                let ty = lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it));
-                Literal::Int(Default::default(), ty)
            }
            LiteralKind::FloatNumber(lit) => {
                let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(&it));
@@ -1077,7 +1082,7 @@ impl From<ast::LiteralKind> for Literal {
            }
            LiteralKind::ByteString(_) => Literal::ByteString(Default::default()),
            LiteralKind::String(_) => Literal::String(Default::default()),
-            LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)),
+            LiteralKind::Byte => Literal::Uint(Default::default(), Some(BuiltinUint::U8)),
            LiteralKind::Bool(val) => Literal::Bool(val),
            LiteralKind::Char => Literal::Char(Default::default()),
        }
diff --git a/crates/hir_def/src/builtin_type.rs b/crates/hir_def/src/builtin_type.rs
index 0f872b5c0..7cbaf30b8 100644
--- a/crates/hir_def/src/builtin_type.rs
+++ b/crates/hir_def/src/builtin_type.rs
@@ -6,38 +6,32 @@
 use std::fmt;
 use hir_expand::name::{name, AsName, Name};
+/// Different signed int types.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Signedness {
+pub enum BuiltinInt {
-    Signed,
+    Isize,
-    Unsigned,
+    I8,
-}
+    I16,
+    I32,
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+    I64,
-pub enum IntBitness {
+    I128,
-    Xsize,
-    X8,
-    X16,
-    X32,
-    X64,
-    X128,
-}
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum FloatBitness {
-    X32,
-    X64,
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+/// Different unsigned int types.
-pub struct BuiltinInt {
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub signedness: Signedness,
+pub enum BuiltinUint {
-    pub bitness: IntBitness,
+    Usize,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct BuiltinFloat {
+pub enum BuiltinFloat {
-    pub bitness: FloatBitness,
+    F32,
+    F64,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -46,6 +40,7 @@ pub enum BuiltinType {
    Bool,
    Str,
    Int(BuiltinInt),
+    Uint(BuiltinUint),
    Float(BuiltinFloat),
 }
@@ -56,19 +51,19 @@ impl BuiltinType {
        (name![bool], BuiltinType::Bool),
        (name![str],  BuiltinType::Str),
-        (name![isize], BuiltinType::Int(BuiltinInt::ISIZE)),
+        (name![isize], BuiltinType::Int(BuiltinInt::Isize)),
        (name![i8],    BuiltinType::Int(BuiltinInt::I8)),
        (name![i16],   BuiltinType::Int(BuiltinInt::I16)),
        (name![i32],   BuiltinType::Int(BuiltinInt::I32)),
        (name![i64],   BuiltinType::Int(BuiltinInt::I64)),
        (name![i128],  BuiltinType::Int(BuiltinInt::I128)),
-        (name![usize], BuiltinType::Int(BuiltinInt::USIZE)),
+        (name![usize], BuiltinType::Uint(BuiltinUint::Usize)),
-        (name![u8],    BuiltinType::Int(BuiltinInt::U8)),
+        (name![u8],    BuiltinType::Uint(BuiltinUint::U8)),
-        (name![u16],   BuiltinType::Int(BuiltinInt::U16)),
+        (name![u16],   BuiltinType::Uint(BuiltinUint::U16)),
-        (name![u32],   BuiltinType::Int(BuiltinInt::U32)),
+        (name![u32],   BuiltinType::Uint(BuiltinUint::U32)),
-        (name![u64],   BuiltinType::Int(BuiltinInt::U64)),
+        (name![u64],   BuiltinType::Uint(BuiltinUint::U64)),
-        (name![u128],  BuiltinType::Int(BuiltinInt::U128)),
+        (name![u128],  BuiltinType::Uint(BuiltinUint::U128)),
        (name![f32], BuiltinType::Float(BuiltinFloat::F32)),
        (name![f64], BuiltinType::Float(BuiltinFloat::F64)),
@@ -81,24 +76,25 @@ impl AsName for BuiltinType {
            BuiltinType::Char => name![char],
            BuiltinType::Bool => name![bool],
            BuiltinType::Str => name![str],
-            BuiltinType::Int(BuiltinInt { signedness, bitness }) => match (signedness, bitness) {
+            BuiltinType::Int(it) => match it {
-                (Signedness::Signed, IntBitness::Xsize) => name![isize],
+                BuiltinInt::Isize => name![isize],
-                (Signedness::Signed, IntBitness::X8) => name![i8],
+                BuiltinInt::I8 => name![i8],
-                (Signedness::Signed, IntBitness::X16) => name![i16],
+                BuiltinInt::I16 => name![i16],
-                (Signedness::Signed, IntBitness::X32) => name![i32],
+                BuiltinInt::I32 => name![i32],
-                (Signedness::Signed, IntBitness::X64) => name![i64],
+                BuiltinInt::I64 => name![i64],
-                (Signedness::Signed, IntBitness::X128) => name![i128],
+                BuiltinInt::I128 => name![i128],
+            },
-                (Signedness::Unsigned, IntBitness::Xsize) => name![usize],
+            BuiltinType::Uint(it) => match it {
-                (Signedness::Unsigned, IntBitness::X8) => name![u8],
+                BuiltinUint::Usize => name![usize],
-                (Signedness::Unsigned, IntBitness::X16) => name![u16],
+                BuiltinUint::U8 => name![u8],
-                (Signedness::Unsigned, IntBitness::X32) => name![u32],
+                BuiltinUint::U16 => name![u16],
-                (Signedness::Unsigned, IntBitness::X64) => name![u64],
+                BuiltinUint::U32 => name![u32],
-                (Signedness::Unsigned, IntBitness::X128) => name![u128],
+                BuiltinUint::U64 => name![u64],
+                BuiltinUint::U128 => name![u128],
            },
-            BuiltinType::Float(BuiltinFloat { bitness }) => match bitness {
+            BuiltinType::Float(it) => match it {
-                FloatBitness::X32 => name![f32],
+                BuiltinFloat::F32 => name![f32],
-                FloatBitness::X64 => name![f64],
+                BuiltinFloat::F64 => name![f64],
            },
        }
    }
@@ -113,31 +109,26 @@ impl fmt::Display for BuiltinType {
 #[rustfmt::skip]
 impl BuiltinInt {
-    pub const ISIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::Xsize   };
-    pub const I8   : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X8      };
-    pub const I16  : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X16     };
-    pub const I32  : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X32     };
-    pub const I64  : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X64     };
-    pub const I128 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X128    };
-    pub const USIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize };
-    pub const U8   : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X8    };
-    pub const U16  : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X16   };
-    pub const U32  : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X32   };
-    pub const U64  : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X64   };
-    pub const U128 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X128  };
    pub fn from_suffix(suffix: &str) -> Option<BuiltinInt> {
        let res = match suffix {
-            "isize" => Self::ISIZE,
+            "isize" => Self::Isize,
            "i8"    => Self::I8,
            "i16"   => Self::I16,
            "i32"   => Self::I32,
            "i64"   => Self::I64,
            "i128"  => Self::I128,
-            "usize" => Self::USIZE,
+            _ => return None,
+        };
+        Some(res)
+    }
+}
+#[rustfmt::skip]
+impl BuiltinUint {
+    pub fn from_suffix(suffix: &str) -> Option<BuiltinUint> {
+        let res = match suffix {
+            "usize" => Self::Usize,
            "u8"    => Self::U8,
            "u16"   => Self::U16,
            "u32"   => Self::U32,
@@ -152,9 +143,6 @@ impl BuiltinInt {
 #[rustfmt::skip]
 impl BuiltinFloat {
-    pub const F32: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X32 };
-    pub const F64: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X64 };
    pub fn from_suffix(suffix: &str) -> Option<BuiltinFloat> {
        let res = match suffix {
            "f32" => BuiltinFloat::F32,
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 4d72eaeaf..24be93773 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -17,7 +17,7 @@ use la_arena::{Idx, RawIdx};
 use syntax::ast::RangeOp;
 use crate::{
-    builtin_type::{BuiltinFloat, BuiltinInt},
+    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
    BlockId,
@@ -43,6 +43,7 @@ pub enum Literal {
    Char(char),
    Bool(bool),
    Int(u64, Option<BuiltinInt>),
+    Uint(u64, Option<BuiltinUint>),
    Float(u64, Option<BuiltinFloat>), // FIXME: f64 is not Eq
 }
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 5e2a711b8..3e19a7702 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -1,5 +1,7 @@
 //! An algorithm to find a path to refer to a certain item.
+use std::iter;
 use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
@@ -95,7 +97,7 @@ fn find_path_inner(
    item: ItemInNs,
    from: ModuleId,
    max_len: usize,
-    prefixed: Option<PrefixKind>,
+    mut prefixed: Option<PrefixKind>,
 ) -> Option<ModPath> {
    if max_len == 0 {
        return None;
@@ -114,8 +116,9 @@ fn find_path_inner(
    }
    // - if the item is the crate root, return `crate`
-    let root = def_map.module_id(def_map.root());
+    let root = def_map.crate_root(db);
    if item == ItemInNs::Types(ModuleDefId::ModuleId(root)) && def_map.block_id().is_none() {
+        // FIXME: the `block_id()` check should be unnecessary, but affects the result
        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
    }
@@ -165,7 +168,7 @@ fn find_path_inner(
    // - otherwise, look for modules containing (reexporting) it and import it from one of those
-    let crate_root = def_map.module_id(def_map.root());
+    let crate_root = def_map.crate_root(db);
    let crate_attrs = db.attrs(crate_root.into());
    let prefer_no_std = crate_attrs.by_key("no_std").exists();
    let mut best_path = None;
@@ -228,12 +231,16 @@ fn find_path_inner(
        }
    }
-    if let Some(mut prefix) = prefixed.map(PrefixKind::prefix) {
+    // If the item is declared inside a block expression, don't use a prefix, as we don't handle
-        if matches!(prefix, PathKind::Crate | PathKind::Super(0)) && def_map.block_id().is_some() {
+    // that correctly (FIXME).
-            // Inner items cannot be referred to via `crate::` or `self::` paths.
+    if let Some(item_module) = item.as_module_def_id().and_then(|did| did.module(db)) {
-            prefix = PathKind::Plain;
+        if item_module.def_map(db).block_id().is_some() && prefixed.is_some() {
+            mark::hit!(prefixed_in_block_expression);
+            prefixed = Some(PrefixKind::Plain);
        }
+    }
+    if let Some(prefix) = prefixed.map(PrefixKind::prefix) {
        best_path.or_else(|| {
            scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name]))
        })
@@ -285,12 +292,12 @@ fn find_local_import_locations(
    let data = &def_map[from.local_id];
    let mut worklist =
        data.children.values().map(|child| def_map.module_id(*child)).collect::<Vec<_>>();
-    let mut parent = data.parent;
+    for ancestor in iter::successors(from.containing_module(db), |m| m.containing_module(db)) {
-    while let Some(p) = parent {
+        worklist.push(ancestor);
-        worklist.push(def_map.module_id(p));
-        parent = def_map[p].parent;
    }
+    let def_map = def_map.crate_root(db).def_map(db);
    let mut seen: FxHashSet<_> = FxHashSet::default();
    let mut locations = Vec::new();
@@ -301,7 +308,14 @@ fn find_local_import_locations(
        let ext_def_map;
        let data = if module.krate == from.krate {
-            &def_map[module.local_id]
+            if module.block.is_some() {
+                // Re-query the block's DefMap
+                ext_def_map = module.def_map(db);
+                &ext_def_map[module.local_id]
+            } else {
+                // Reuse the root DefMap
+                &def_map[module.local_id]
+            }
        } else {
            // The crate might reexport a module defined in another crate.
            ext_def_map = module.def_map(db);
@@ -828,6 +842,7 @@ mod tests {
    #[test]
    fn inner_items_from_inner_module() {
+        mark::check!(prefixed_in_block_expression);
        check_found_path(
            r#"
            fn main() {
@@ -869,4 +884,24 @@ mod tests {
            "super::Struct",
        );
    }
+    #[test]
+    fn outer_items_with_inner_items_present() {
+        check_found_path(
+            r#"
+            mod module {
+                pub struct CompleteMe;
+            }
+            fn main() {
+                fn inner() {}
+                $0
+            }
+            "#,
+            "module::CompleteMe",
+            "module::CompleteMe",
+            "crate::module::CompleteMe",
+            "self::module::CompleteMe",
+        )
+    }
 }
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index ee46c3330..4e5daa2ff 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -12,8 +12,8 @@ use stdx::format_to;
 use test_utils::mark;
 use crate::{
-    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId,
-    LocalModuleId, Lookup, MacroDefId, ModuleDefId, ModuleId, TraitId,
+    LocalModuleId, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
 #[derive(Copy, Clone)]
@@ -375,19 +375,9 @@ impl ItemInNs {
    /// Returns the crate defining this item (or `None` if `self` is built-in).
    pub fn krate(&self, db: &dyn DefDatabase) -> Option<CrateId> {
-        Some(match self {
+        match self {
-            ItemInNs::Types(did) | ItemInNs::Values(did) => match did {
+            ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate),
-                ModuleDefId::ModuleId(id) => id.krate,
+            ItemInNs::Macros(id) => Some(id.krate),
-                ModuleDefId::FunctionId(id) => id.lookup(db).module(db).krate,
+        }
-                ModuleDefId::AdtId(id) => id.module(db).krate,
-                ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db).krate,
-                ModuleDefId::ConstId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::StaticId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::TraitId(id) => id.lookup(db).container.module(db).krate,
-                ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db).krate,
-                ModuleDefId::BuiltinType(_) => return None,
-            },
-            ItemInNs::Macros(id) => return Some(id.krate),
-        })
    }
 }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 6802bc250..4498d94bb 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -97,6 +97,10 @@ impl ModuleId {
    pub fn krate(&self) -> CrateId {
        self.krate
    }
+    pub fn containing_module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
+        self.def_map(db).containing_module(self.local_id)
+    }
 }
 /// An ID of a module, **local** to a specific crate
@@ -529,6 +533,25 @@ impl HasModule for StaticLoc {
    }
 }
+impl ModuleDefId {
+    /// Returns the module containing `self` (or `self`, if `self` is itself a module).
+    ///
+    /// Returns `None` if `self` refers to a primitive type.
+    pub fn module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
+        Some(match self {
+            ModuleDefId::ModuleId(id) => *id,
+            ModuleDefId::FunctionId(id) => id.lookup(db).module(db),
+            ModuleDefId::AdtId(id) => id.module(db),
+            ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db),
+            ModuleDefId::ConstId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::StaticId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TraitId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db),
+            ModuleDefId::BuiltinType(_) => return None,
+        })
+    }
+}
 impl AttrDefId {
    pub fn krate(&self, db: &dyn db::DefDatabase) -> CrateId {
        match self {
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 6a3456f2e..003d668ca 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -343,6 +343,18 @@ impl DefMap {
        Some(self.block?.parent)
    }
+    /// Returns the module containing `local_mod`, either the parent `mod`, or the module containing
+    /// the block, if `self` corresponds to a block expression.
+    pub fn containing_module(&self, local_mod: LocalModuleId) -> Option<ModuleId> {
+        match &self[local_mod].parent {
+            Some(parent) => Some(self.module_id(*parent)),
+            None => match &self.block {
+                Some(block) => Some(block.parent),
+                None => None,
+            },
+        }
+    }
    // FIXME: this can use some more human-readable format (ideally, an IR
    // even), as this should be a great debugging aid.
    pub fn dump(&self, db: &dyn DefDatabase) -> String {
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index a469546c1..505493a74 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -101,8 +101,12 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                break;
            }
            ast::PathSegmentKind::SelfKw => {
-                kind = PathKind::Super(0);
+                // don't break out if `self` is the last segment of a path, this mean we got an
-                break;
+                // use tree like `foo::{self}` which we want to resolve as `foo`
+                if !segments.is_empty() {
+                    kind = PathKind::Super(0);
+                    break;
+                }
            }
            ast::PathSegmentKind::SuperKw => {
                let nested_super_count = if let PathKind::Super(n) = kind { n } else { 0 };
@@ -117,6 +121,11 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    segments.reverse();
    generic_args.reverse();
+    if segments.is_empty() && kind == PathKind::Plain && type_anchor.is_none() {
+        // plain empty paths don't exist, this means we got a single `self` segment as our path
+        kind = PathKind::Super(0);
+    }
    // handle local_inner_macros :
    // Basically, even in rustc it is quite hacky:
    // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 6ef9d1e7e..d1302d749 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.58", default-features = false }
+chalk-solve = { version = "0.59", default-features = false }
-chalk-ir = "0.58"
+chalk-ir = "0.59"
-chalk-recursive = "0.58"
+chalk-recursive = "0.59"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index ece68183e..be1fd1f13 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -81,7 +81,7 @@ fn deref_by_trait(
    // Now do the assoc type projection
    let projection = super::traits::ProjectionPredicate {
-        ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())),
+        ty: Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())),
        projection_ty: super::ProjectionTy { associated_ty: target, parameters },
    };
@@ -89,8 +89,10 @@ fn deref_by_trait(
    let in_env = InEnvironment { value: obligation, environment: ty.environment };
-    let canonical =
+    let canonical = Canonical::new(
-        Canonical::new(in_env, ty.value.kinds.iter().copied().chain(Some(super::TyKind::General)));
+        in_env,
+        ty.value.kinds.iter().copied().chain(Some(chalk_ir::TyVariableKind::General)),
+    );
    let solution = db.trait_solve(krate, canonical)?;
@@ -112,7 +114,8 @@ fn deref_by_trait(
            // new variables in that case
            for i in 1..vars.0.kinds.len() {
-                if vars.0.value[i - 1] != Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
+                if vars.0.value[i - 1]
+                    != Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
                    return None;
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index d740b7265..66a88e2b6 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -17,7 +17,7 @@ use crate::{
        MissingPatFields, RemoveThisSemicolon,
    },
    utils::variant_data,
-    ApplicationTy, InferenceResult, Ty, TypeCtor,
+    InferenceResult, Ty,
 };
 pub(crate) use hir_def::{
@@ -381,14 +381,11 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            _ => return,
        };
-        let core_result_ctor = TypeCtor::Adt(AdtId::EnumId(core_result_enum));
+        let (params, required) = match mismatch.expected {
-        let core_option_ctor = TypeCtor::Adt(AdtId::EnumId(core_option_enum));
+            Ty::Adt(AdtId::EnumId(enum_id), ref parameters) if enum_id == core_result_enum => {
-        let (params, required) = match &mismatch.expected {
-            Ty::Apply(ApplicationTy { ctor, parameters }) if ctor == &core_result_ctor => {
                (parameters, "Ok".to_string())
            }
-            Ty::Apply(ApplicationTy { ctor, parameters }) if ctor == &core_option_ctor => {
+            Ty::Adt(AdtId::EnumId(enum_id), ref parameters) if enum_id == core_option_enum => {
                (parameters, "Some".to_string())
            }
            _ => return,
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 1c1423fbf..86fee0050 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -227,7 +227,7 @@ use hir_def::{
 use la_arena::Idx;
 use smallvec::{smallvec, SmallVec};
-use crate::{db::HirDatabase, ApplicationTy, InferenceResult, Ty, TypeCtor};
+use crate::{db::HirDatabase, InferenceResult, Ty};
 #[derive(Debug, Clone, Copy)]
 /// Either a pattern from the source code being analyzed, represented as
@@ -627,14 +627,12 @@ pub(super) fn is_useful(
    // - `!` type
    // In those cases, no match arm is useful.
    match cx.infer[cx.match_expr].strip_references() {
-        Ty::Apply(ApplicationTy { ctor: TypeCtor::Adt(AdtId::EnumId(enum_id)), .. }) => {
+        Ty::Adt(AdtId::EnumId(enum_id), ..) => {
            if cx.db.enum_data(*enum_id).variants.is_empty() {
                return Ok(Usefulness::NotUseful);
            }
        }
-        Ty::Apply(ApplicationTy { ctor: TypeCtor::Never, .. }) => {
+        Ty::Never => return Ok(Usefulness::NotUseful),
-            return Ok(Usefulness::NotUseful);
-        }
        _ => (),
    }
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 9c506112d..e77a20fea 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -11,9 +11,7 @@ use hir_def::{
 };
 use hir_expand::diagnostics::DiagnosticSink;
-use crate::{
+use crate::{db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Ty};
-    db::HirDatabase, diagnostics::MissingUnsafe, ApplicationTy, InferenceResult, Ty, TypeCtor,
-};
 pub(super) struct UnsafeValidator<'a, 'b: 'a> {
    owner: DefWithBodyId,
@@ -112,7 +110,7 @@ fn walk_unsafe(
            }
        }
        Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
-            if let Ty::Apply(ApplicationTy { ctor: TypeCtor::RawPtr(..), .. }) = &infer[*expr] {
+            if let Ty::Raw(..) = &infer[*expr] {
                unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
            }
        }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 271fcbfaf..d4a8b48e6 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -3,10 +3,12 @@
 use std::{borrow::Cow, fmt};
 use crate::{
-    db::HirDatabase, utils::generics, ApplicationTy, CallableDefId, FnSig, GenericPredicate,
+    db::HirDatabase, primitive, utils::generics, AliasTy, CallableDefId, CallableSig,
-    Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    GenericPredicate, Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs,
+    TraitRef, Ty,
 };
 use arrayvec::ArrayVec;
+use chalk_ir::Mutability;
 use hir_def::{
    db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs, AdtId,
    AssocContainerId, HasModule, Lookup, ModuleId, TraitId,
@@ -234,39 +236,79 @@ impl HirDisplay for &Ty {
    }
 }
-impl HirDisplay for ApplicationTy {
+impl HirDisplay for ProjectionTy {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        match self.ctor {
+        let trait_ = f.db.trait_data(self.trait_(f.db));
-            TypeCtor::Bool => write!(f, "bool")?,
+        let first_parameter = self.parameters[0].into_displayable(
-            TypeCtor::Char => write!(f, "char")?,
+            f.db,
-            TypeCtor::Int(t) => write!(f, "{}", t)?,
+            f.max_size,
-            TypeCtor::Float(t) => write!(f, "{}", t)?,
+            f.omit_verbose_types,
-            TypeCtor::Str => write!(f, "str")?,
+            f.display_target,
-            TypeCtor::Slice => {
+        );
-                let t = self.parameters.as_single();
+        write!(f, "<{} as {}", first_parameter, trait_.name)?;
+        if self.parameters.len() > 1 {
+            write!(f, "<")?;
+            f.write_joined(&self.parameters[1..], ", ")?;
+            write!(f, ">")?;
+        }
+        write!(f, ">::{}", f.db.type_alias_data(self.associated_ty).name)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Ty {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        if f.should_truncate() {
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
+        }
+        match self {
+            Ty::Never => write!(f, "!")?,
+            Ty::Str => write!(f, "str")?,
+            Ty::Scalar(Scalar::Bool) => write!(f, "bool")?,
+            Ty::Scalar(Scalar::Char) => write!(f, "char")?,
+            &Ty::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?,
+            &Ty::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
+            &Ty::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
+            Ty::Slice(parameters) => {
+                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "]")?;
            }
-            TypeCtor::Array => {
+            Ty::Array(parameters) => {
-                let t = self.parameters.as_single();
+                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "; _]")?;
            }
-            TypeCtor::RawPtr(m) | TypeCtor::Ref(m) => {
+            Ty::Raw(m, parameters) | Ty::Ref(m, parameters) => {
-                let t = self.parameters.as_single();
+                let t = parameters.as_single();
                let ty_display =
                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
-                if matches!(self.ctor, TypeCtor::RawPtr(_)) {
+                if matches!(self, Ty::Raw(..)) {
-                    write!(f, "*{}", m.as_keyword_for_ptr())?;
+                    write!(
+                        f,
+                        "*{}",
+                        match m {
+                            Mutability::Not => "const ",
+                            Mutability::Mut => "mut ",
+                        }
+                    )?;
                } else {
-                    write!(f, "&{}", m.as_keyword_for_ref())?;
+                    write!(
+                        f,
+                        "&{}",
+                        match m {
+                            Mutability::Not => "",
+                            Mutability::Mut => "mut ",
+                        }
+                    )?;
                }
                let datas;
@@ -274,10 +316,10 @@ impl HirDisplay for ApplicationTy {
                    Ty::Dyn(predicates) if predicates.len() > 1 => {
                        Cow::Borrowed(predicates.as_ref())
                    }
-                    &Ty::Opaque(OpaqueTy {
+                    &Ty::Alias(AliasTy::Opaque(OpaqueTy {
                        opaque_ty_id: OpaqueTyId::ReturnTypeImplTrait(func, idx),
                        ref parameters,
-                    }) => {
+                    })) => {
                        datas =
                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
                        let data = (*datas)
@@ -304,25 +346,24 @@ impl HirDisplay for ApplicationTy {
                    write!(f, "{}", ty_display)?;
                }
            }
-            TypeCtor::Never => write!(f, "!")?,
+            Ty::Tuple(_, substs) => {
-            TypeCtor::Tuple { .. } => {
+                if substs.len() == 1 {
-                let ts = &self.parameters;
-                if ts.len() == 1 {
                    write!(f, "(")?;
-                    ts[0].hir_fmt(f)?;
+                    substs[0].hir_fmt(f)?;
                    write!(f, ",)")?;
                } else {
                    write!(f, "(")?;
-                    f.write_joined(&*ts.0, ", ")?;
+                    f.write_joined(&*substs.0, ", ")?;
                    write!(f, ")")?;
                }
            }
-            TypeCtor::FnPtr { is_varargs, .. } => {
+            Ty::Function(fn_ptr) => {
-                let sig = FnSig::from_fn_ptr_substs(&self.parameters, is_varargs);
+                let sig = CallableSig::from_fn_ptr(fn_ptr);
                sig.hir_fmt(f)?;
            }
-            TypeCtor::FnDef(def) => {
+            Ty::FnDef(def, parameters) => {
-                let sig = f.db.callable_item_signature(def).subst(&self.parameters);
+                let def = *def;
+                let sig = f.db.callable_item_signature(def).subst(parameters);
                match def {
                    CallableDefId::FunctionId(ff) => {
                        write!(f, "fn {}", f.db.function_data(ff).name)?
@@ -332,7 +373,7 @@ impl HirDisplay for ApplicationTy {
                        write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)?
                    }
                };
-                if self.parameters.len() > 0 {
+                if parameters.len() > 0 {
                    let generics = generics(f.db.upcast(), def.into());
                    let (parent_params, self_param, type_params, _impl_trait_params) =
                        generics.provenance_split();
@@ -340,7 +381,7 @@ impl HirDisplay for ApplicationTy {
                    // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?
                    if total_len > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&self.parameters.0[..total_len], ", ")?;
+                        f.write_joined(&parameters.0[..total_len], ", ")?;
                        write!(f, ">")?;
                    }
                }
@@ -359,10 +400,10 @@ impl HirDisplay for ApplicationTy {
                    write!(f, " -> {}", ret_display)?;
                }
            }
-            TypeCtor::Adt(def_id) => {
+            Ty::Adt(def_id, parameters) => {
                match f.display_target {
                    DisplayTarget::Diagnostics | DisplayTarget::Test => {
-                        let name = match def_id {
+                        let name = match *def_id {
                            AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
                            AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
                            AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
@@ -372,7 +413,7 @@ impl HirDisplay for ApplicationTy {
                    DisplayTarget::SourceCode { module_id } => {
                        if let Some(path) = find_path::find_path(
                            f.db.upcast(),
-                            ItemInNs::Types(def_id.into()),
+                            ItemInNs::Types((*def_id).into()),
                            module_id,
                        ) {
                            write!(f, "{}", path)?;
@@ -384,19 +425,18 @@ impl HirDisplay for ApplicationTy {
                    }
                }
-                if self.parameters.len() > 0 {
+                if parameters.len() > 0 {
                    let parameters_to_write =
                        if f.display_target.is_source_code() || f.omit_verbose_types() {
                            match self
-                                .ctor
                                .as_generic_def()
                                .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
                                .filter(|defaults| !defaults.is_empty())
                            {
-                                None => self.parameters.0.as_ref(),
+                                None => parameters.0.as_ref(),
                                Some(default_parameters) => {
                                    let mut default_from = 0;
-                                    for (i, parameter) in self.parameters.iter().enumerate() {
+                                    for (i, parameter) in parameters.iter().enumerate() {
                                        match (parameter, default_parameters.get(i)) {
                                            (&Ty::Unknown, _) | (_, None) => {
                                                default_from = i + 1;
@@ -404,18 +444,18 @@ impl HirDisplay for ApplicationTy {
                                            (_, Some(default_parameter)) => {
                                                let actual_default = default_parameter
                                                    .clone()
-                                                    .subst(&self.parameters.prefix(i));
+                                                    .subst(&parameters.prefix(i));
                                                if parameter != &actual_default {
                                                    default_from = i + 1;
                                                }
                                            }
                                        }
                                    }
-                                    &self.parameters.0[0..default_from]
+                                    &parameters.0[0..default_from]
                                }
                            }
                        } else {
-                            self.parameters.0.as_ref()
+                            parameters.0.as_ref()
                        };
                    if !parameters_to_write.is_empty() {
                        write!(f, "<")?;
@@ -424,61 +464,54 @@ impl HirDisplay for ApplicationTy {
                    }
                }
            }
-            TypeCtor::AssociatedType(type_alias) => {
+            Ty::AssociatedType(type_alias, parameters) => {
                let trait_ = match type_alias.lookup(f.db.upcast()).container {
                    AssocContainerId::TraitId(it) => it,
                    _ => panic!("not an associated type"),
                };
                let trait_ = f.db.trait_data(trait_);
-                let type_alias_data = f.db.type_alias_data(type_alias);
+                let type_alias_data = f.db.type_alias_data(*type_alias);
                // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)
                if f.display_target.is_test() {
                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
-                    if self.parameters.len() > 0 {
+                    if parameters.len() > 0 {
                        write!(f, "<")?;
-                        f.write_joined(&*self.parameters.0, ", ")?;
+                        f.write_joined(&*parameters.0, ", ")?;
                        write!(f, ">")?;
                    }
                } else {
-                    let projection_ty = ProjectionTy {
+                    let projection_ty =
-                        associated_ty: type_alias,
+                        ProjectionTy { associated_ty: *type_alias, parameters: parameters.clone() };
-                        parameters: self.parameters.clone(),
-                    };
                    projection_ty.hir_fmt(f)?;
                }
            }
-            TypeCtor::ForeignType(type_alias) => {
+            Ty::ForeignType(type_alias) => {
-                let type_alias = f.db.type_alias_data(type_alias);
+                let type_alias = f.db.type_alias_data(*type_alias);
                write!(f, "{}", type_alias.name)?;
-                if self.parameters.len() > 0 {
-                    write!(f, "<")?;
-                    f.write_joined(&*self.parameters.0, ", ")?;
-                    write!(f, ">")?;
-                }
            }
-            TypeCtor::OpaqueType(opaque_ty_id) => {
+            Ty::OpaqueType(opaque_ty_id, parameters) => {
                match opaque_ty_id {
-                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+                    &OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
                        let datas =
                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
                        let data = (*datas)
                            .as_ref()
                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                        let bounds = data.subst(&self.parameters);
+                        let bounds = data.subst(&parameters);
                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?;
                        // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution
                    }
                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => {
                        write!(f, "impl Future<Output = ")?;
-                        self.parameters[0].hir_fmt(f)?;
+                        parameters[0].hir_fmt(f)?;
                        write!(f, ">")?;
                    }
                }
            }
-            TypeCtor::Closure { .. } => {
+            Ty::Closure(.., substs) => {
-                let sig = self.parameters[0].callable_sig(f.db);
+                let sig = substs[0].callable_sig(f.db);
                if let Some(sig) = sig {
                    if sig.params().is_empty() {
                        write!(f, "||")?;
@@ -501,44 +534,6 @@ impl HirDisplay for ApplicationTy {
                    write!(f, "{{closure}}")?;
                }
            }
-        }
-        Ok(())
-    }
-}
-impl HirDisplay for ProjectionTy {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{}", TYPE_HINT_TRUNCATION);
-        }
-        let trait_ = f.db.trait_data(self.trait_(f.db));
-        let first_parameter = self.parameters[0].into_displayable(
-            f.db,
-            f.max_size,
-            f.omit_verbose_types,
-            f.display_target,
-        );
-        write!(f, "<{} as {}", first_parameter, trait_.name)?;
-        if self.parameters.len() > 1 {
-            write!(f, "<")?;
-            f.write_joined(&self.parameters[1..], ", ")?;
-            write!(f, ">")?;
-        }
-        write!(f, ">::{}", f.db.type_alias_data(self.associated_ty).name)?;
-        Ok(())
-    }
-}
-impl HirDisplay for Ty {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        if f.should_truncate() {
-            return write!(f, "{}", TYPE_HINT_TRUNCATION);
-        }
-        match self {
-            Ty::Apply(a_ty) => a_ty.hir_fmt(f)?,
-            Ty::Projection(p_ty) => p_ty.hir_fmt(f)?,
            Ty::Placeholder(id) => {
                let generics = generics(f.db.upcast(), id.parent);
                let param_data = &generics.params.types[id.local_id];
@@ -557,11 +552,12 @@ impl HirDisplay for Ty {
                    }
                }
            }
-            Ty::Bound(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
+            Ty::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
            Ty::Dyn(predicates) => {
                write_bounds_like_dyn_trait_with_prefix("dyn", predicates, f)?;
            }
-            Ty::Opaque(opaque_ty) => {
+            Ty::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?,
+            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
                match opaque_ty.opaque_ty_id {
                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
                        let datas =
@@ -585,13 +581,13 @@ impl HirDisplay for Ty {
                }
                write!(f, "{{unknown}}")?;
            }
-            Ty::Infer(..) => write!(f, "_")?,
+            Ty::InferenceVar(..) => write!(f, "_")?,
        }
        Ok(())
    }
 }
-impl HirDisplay for FnSig {
+impl HirDisplay for CallableSig {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        write!(f, "fn(")?;
        f.write_joined(self.params(), ", ")?;
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 4b683c5a7..4d771a91e 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -18,6 +18,7 @@ use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
+use chalk_ir::Mutability;
 use hir_def::{
    body::Body,
    data::{ConstData, FunctionData, StaticData},
@@ -25,7 +26,7 @@ use hir_def::{
    lang_item::LangItemTarget,
    path::{path, Path},
    resolver::{HasResolver, Resolver, TypeNs},
-    type_ref::{Mutability, TypeRef},
+    type_ref::TypeRef,
    AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, Lookup, TraitId,
    TypeAliasId, VariantId,
 };
@@ -36,25 +37,15 @@ use stdx::impl_from;
 use syntax::SmolStr;
 use super::{
-    primitive::{FloatTy, IntTy},
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk,
+    InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
-    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
+    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode, AliasTy,
 };
 pub(crate) use unify::unify;
-macro_rules! ty_app {
-    ($ctor:pat, $param:pat) => {
-        crate::Ty::Apply(crate::ApplicationTy { ctor: $ctor, parameters: $param })
-    };
-    ($ctor:pat) => {
-        ty_app!($ctor, _)
-    };
-}
 mod unify;
 mod path;
 mod expr;
@@ -97,7 +88,7 @@ impl BindingMode {
    fn convert(annotation: BindingAnnotation) -> BindingMode {
        match annotation {
            BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move,
-            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Shared),
+            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Not),
            BindingAnnotation::RefMut => BindingMode::Ref(Mutability::Mut),
        }
    }
@@ -405,7 +396,7 @@ impl<'a> InferenceContext<'a> {
    fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty {
        let ty = self.resolve_ty_as_possible(ty);
        ty.fold(&mut |ty| match ty {
-            Ty::Projection(proj_ty) => self.normalize_projection_ty(proj_ty),
+            Ty::Alias(AliasTy::Projection(proj_ty)) => self.normalize_projection_ty(proj_ty),
            _ => ty,
        })
    }
@@ -664,30 +655,17 @@ impl<'a> InferenceContext<'a> {
 /// two are used for inference of literal values (e.g. `100` could be one of
 /// several integer types).
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub enum InferTy {
+pub struct InferenceVar {
-    TypeVar(unify::TypeVarId),
+    index: u32,
-    IntVar(unify::TypeVarId),
-    FloatVar(unify::TypeVarId),
-    MaybeNeverTypeVar(unify::TypeVarId),
 }
-impl InferTy {
+impl InferenceVar {
    fn to_inner(self) -> unify::TypeVarId {
-        match self {
+        unify::TypeVarId(self.index)
-            InferTy::TypeVar(ty)
-            | InferTy::IntVar(ty)
-            | InferTy::FloatVar(ty)
-            | InferTy::MaybeNeverTypeVar(ty) => ty,
-        }
    }
-    fn fallback_value(self) -> Ty {
+    fn from_inner(unify::TypeVarId(index): unify::TypeVarId) -> Self {
-        match self {
+        InferenceVar { index }
-            InferTy::TypeVar(..) => Ty::Unknown,
-            InferTy::IntVar(..) => Ty::simple(TypeCtor::Int(IntTy::i32())),
-            InferTy::FloatVar(..) => Ty::simple(TypeCtor::Float(FloatTy::f64())),
-            InferTy::MaybeNeverTypeVar(..) => Ty::simple(TypeCtor::Never),
-        }
    }
 }
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 32c7c57cd..cf0a3add4 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -4,12 +4,13 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
-use hir_def::{lang_item::LangItemTarget, type_ref::Mutability};
+use chalk_ir::{Mutability, TyVariableKind};
+use hir_def::lang_item::LangItemTarget;
 use test_utils::mark;
-use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty, TypeCtor};
+use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty};
-use super::{unify::TypeVarValue, InEnvironment, InferTy, InferenceContext};
+use super::{InEnvironment, InferenceContext};
 impl<'a> InferenceContext<'a> {
    /// Unify two types, but may coerce the first one to the second one
@@ -33,7 +34,7 @@ impl<'a> InferenceContext<'a> {
        } else if self.coerce(ty2, ty1) {
            ty1.clone()
        } else {
-            if let (ty_app!(TypeCtor::FnDef(_)), ty_app!(TypeCtor::FnDef(_))) = (ty1, ty2) {
+            if let (Ty::FnDef(..), Ty::FnDef(..)) = (ty1, ty2) {
                mark::hit!(coerce_fn_reification);
                // Special case: two function types. Try to coerce both to
                // pointers to have a chance at getting a match. See
@@ -53,12 +54,11 @@ impl<'a> InferenceContext<'a> {
    fn coerce_inner(&mut self, mut from_ty: Ty, to_ty: &Ty) -> bool {
        match (&from_ty, to_ty) {
            // Never type will make type variable to fallback to Never Type instead of Unknown.
-            (ty_app!(TypeCtor::Never), Ty::Infer(InferTy::TypeVar(tv))) => {
+            (Ty::Never, Ty::InferenceVar(tv, TyVariableKind::General)) => {
-                let var = self.table.new_maybe_never_type_var();
+                self.table.type_variable_table.set_diverging(*tv, true);
-                self.table.var_unification_table.union_value(*tv, TypeVarValue::Known(var));
                return true;
            }
-            (ty_app!(TypeCtor::Never), _) => return true,
+            (Ty::Never, _) => return true,
            // Trivial cases, this should go after `never` check to
            // avoid infer result type to be never
@@ -71,38 +71,33 @@ impl<'a> InferenceContext<'a> {
        // Pointer weakening and function to pointer
        match (&mut from_ty, to_ty) {
-            // `*mut T`, `&mut T, `&T`` -> `*const T`
+            // `*mut T` -> `*const T`
            // `&mut T` -> `&T`
-            // `&mut T` -> `*mut T`
+            (Ty::Raw(m1, ..), Ty::Raw(m2 @ Mutability::Not, ..))
-            (ty_app!(c1@TypeCtor::RawPtr(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
+            | (Ty::Ref(m1, ..), Ty::Ref(m2 @ Mutability::Not, ..)) => {
-            | (ty_app!(c1@TypeCtor::Ref(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
+                *m1 = *m2;
-            | (ty_app!(c1@TypeCtor::Ref(_)), ty_app!(c2@TypeCtor::Ref(Mutability::Shared)))
+            }
-            | (ty_app!(c1@TypeCtor::Ref(Mutability::Mut)), ty_app!(c2@TypeCtor::RawPtr(_))) => {
+            // `&T` -> `*const T`
-                *c1 = *c2;
+            // `&mut T` -> `*mut T`/`*const T`
+            (Ty::Ref(.., substs), &Ty::Raw(m2 @ Mutability::Not, ..))
+            | (Ty::Ref(Mutability::Mut, substs), &Ty::Raw(m2, ..)) => {
+                from_ty = Ty::Raw(m2, substs.clone());
            }
-            // Illegal mutablity conversion
+            // Illegal mutability conversion
-            (
+            (Ty::Raw(Mutability::Not, ..), Ty::Raw(Mutability::Mut, ..))
-                ty_app!(TypeCtor::RawPtr(Mutability::Shared)),
+            | (Ty::Ref(Mutability::Not, ..), Ty::Ref(Mutability::Mut, ..)) => return false,
-                ty_app!(TypeCtor::RawPtr(Mutability::Mut)),
-            )
-            | (
-                ty_app!(TypeCtor::Ref(Mutability::Shared)),
-                ty_app!(TypeCtor::Ref(Mutability::Mut)),
-            ) => return false,
            // `{function_type}` -> `fn()`
-            (ty_app!(TypeCtor::FnDef(_)), ty_app!(TypeCtor::FnPtr { .. })) => {
+            (Ty::FnDef(..), Ty::Function { .. }) => match from_ty.callable_sig(self.db) {
-                match from_ty.callable_sig(self.db) {
+                None => return false,
-                    None => return false,
+                Some(sig) => {
-                    Some(sig) => {
+                    from_ty = Ty::fn_ptr(sig);
-                        from_ty = Ty::fn_ptr(sig);
-                    }
                }
-            }
+            },
-            (ty_app!(TypeCtor::Closure { .. }, params), ty_app!(TypeCtor::FnPtr { .. })) => {
+            (Ty::Closure(.., substs), Ty::Function { .. }) => {
-                from_ty = params[0].clone();
+                from_ty = substs[0].clone();
            }
            _ => {}
@@ -115,9 +110,7 @@ impl<'a> InferenceContext<'a> {
        // Auto Deref if cannot coerce
        match (&from_ty, to_ty) {
            // FIXME: DerefMut
-            (ty_app!(TypeCtor::Ref(_), st1), ty_app!(TypeCtor::Ref(_), st2)) => {
+            (Ty::Ref(_, st1), Ty::Ref(_, st2)) => self.unify_autoderef_behind_ref(&st1[0], &st2[0]),
-                self.unify_autoderef_behind_ref(&st1[0], &st2[0])
-            }
            // Otherwise, normal unify
            _ => self.unify(&from_ty, to_ty),
@@ -178,17 +171,17 @@ impl<'a> InferenceContext<'a> {
            },
        ) {
            let derefed_ty = canonicalized.decanonicalize_ty(derefed_ty.value);
-            match (&*self.resolve_ty_shallow(&derefed_ty), &*to_ty) {
+            let from_ty = self.resolve_ty_shallow(&derefed_ty);
-                // Stop when constructor matches.
+            // Stop when constructor matches.
-                (ty_app!(from_ctor, st1), ty_app!(to_ctor, st2)) if from_ctor == to_ctor => {
+            if from_ty.equals_ctor(&to_ty) {
-                    // It will not recurse to `coerce`.
+                // It will not recurse to `coerce`.
-                    return self.table.unify_substs(st1, st2, 0);
+                return match (from_ty.substs(), to_ty.substs()) {
-                }
+                    (Some(st1), Some(st2)) => self.table.unify_substs(st1, st2, 0),
-                _ => {
+                    (None, None) => true,
-                    if self.table.unify_inner_trivial(&derefed_ty, &to_ty, 0) {
+                    _ => false,
-                        return true;
+                };
-                    }
+            } else if self.table.unify_inner_trivial(&derefed_ty, &to_ty, 0) {
-                }
+                return true;
            }
        }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index cb59a6937..cf1f1038a 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -3,8 +3,8 @@
 use std::iter::{repeat, repeat_with};
 use std::{mem, sync::Arc};
+use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::{
-    builtin_type::Signedness,
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
    resolver::resolver_for_expr,
@@ -15,11 +15,14 @@ use syntax::ast::RangeOp;
 use test_utils::mark;
 use crate::{
-    autoderef, method_resolution, op,
+    autoderef,
+    lower::lower_to_chalk_mutability,
+    method_resolution, op,
+    primitive::{self, UintTy},
    traits::{FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
-    ApplicationTy, Binders, CallableDefId, InferTy, IntTy, Mutability, Obligation, OpaqueTyId,
+    Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar, Substs,
-    Rawness, Substs, TraitRef, Ty, TypeCtor,
+    TraitRef, Ty,
 };
 use super::{
@@ -82,10 +85,7 @@ impl<'a> InferenceContext<'a> {
            arg_tys.push(arg);
        }
        let parameters = param_builder.build();
-        let arg_ty = Ty::Apply(ApplicationTy {
+        let arg_ty = Ty::Tuple(num_args, parameters);
-            ctor: TypeCtor::Tuple { cardinality: num_args as u16 },
-            parameters,
-        });
        let substs =
            Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
@@ -120,7 +120,7 @@ impl<'a> InferenceContext<'a> {
            Expr::Missing => Ty::Unknown,
            Expr::If { condition, then_branch, else_branch } => {
                // if let is desugared to match, so this is always simple if
-                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
+                self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool)));
                let condition_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
                let mut both_arms_diverge = Diverges::Always;
@@ -175,7 +175,7 @@ impl<'a> InferenceContext<'a> {
                // existenail type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType>
                let inner_ty = self.infer_expr(*body, &Expectation::none());
                let opaque_ty_id = OpaqueTyId::AsyncBlockTypeImplTrait(self.owner, *body);
-                Ty::apply_one(TypeCtor::OpaqueType(opaque_ty_id), inner_ty)
+                Ty::OpaqueType(opaque_ty_id, Substs::single(inner_ty))
            }
            Expr::Loop { body, label } => {
                self.breakables.push(BreakableContext {
@@ -193,7 +193,7 @@ impl<'a> InferenceContext<'a> {
                if ctxt.may_break {
                    ctxt.break_ty
                } else {
-                    Ty::simple(TypeCtor::Never)
+                    Ty::Never
                }
            }
            Expr::While { condition, body, label } => {
@@ -203,7 +203,7 @@ impl<'a> InferenceContext<'a> {
                    label: label.map(|label| self.body[label].name.clone()),
                });
                // while let is desugared to a match loop, so this is always simple while
-                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
+                self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool)));
                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                let _ctxt = self.breakables.pop().expect("breakable stack broken");
                // the body may not run, so it diverging doesn't mean we diverge
@@ -250,12 +250,12 @@ impl<'a> InferenceContext<'a> {
                    None => self.table.new_type_var(),
                };
                sig_tys.push(ret_ty.clone());
-                let sig_ty = Ty::apply(
+                let sig_ty = Ty::Function(FnPointer {
-                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1, is_varargs: false },
+                    num_args: sig_tys.len() - 1,
-                    Substs(sig_tys.clone().into()),
+                    sig: FnSig { variadic: false },
-                );
+                    substs: Substs(sig_tys.clone().into()),
-                let closure_ty =
+                });
-                    Ty::apply_one(TypeCtor::Closure { def: self.owner, expr: tgt_expr }, sig_ty);
+                let closure_ty = Ty::Closure(self.owner, tgt_expr, Substs::single(sig_ty));
                // Eagerly try to relate the closure type with the expected
                // type, otherwise we often won't have enough information to
@@ -306,11 +306,8 @@ impl<'a> InferenceContext<'a> {
            Expr::Match { expr, arms } => {
                let input_ty = self.infer_expr(*expr, &Expectation::none());
-                let mut result_ty = if arms.is_empty() {
+                let mut result_ty =
-                    Ty::simple(TypeCtor::Never)
+                    if arms.is_empty() { Ty::Never } else { self.table.new_type_var() };
-                } else {
-                    self.table.new_type_var()
-                };
                let matchee_diverges = self.diverges;
                let mut all_arms_diverge = Diverges::Always;
@@ -321,7 +318,7 @@ impl<'a> InferenceContext<'a> {
                    if let Some(guard_expr) = arm.guard {
                        self.infer_expr(
                            guard_expr,
-                            &Expectation::has_type(Ty::simple(TypeCtor::Bool)),
+                            &Expectation::has_type(Ty::Scalar(Scalar::Bool)),
                        );
                    }
@@ -339,7 +336,7 @@ impl<'a> InferenceContext<'a> {
                let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr);
                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
            }
-            Expr::Continue { .. } => Ty::simple(TypeCtor::Never),
+            Expr::Continue { .. } => Ty::Never,
            Expr::Break { expr, label } => {
                let val_ty = if let Some(expr) = expr {
                    self.infer_expr(*expr, &Expectation::none())
@@ -364,8 +361,7 @@ impl<'a> InferenceContext<'a> {
                        expr: tgt_expr,
                    });
                }
+                Ty::Never
-                Ty::simple(TypeCtor::Never)
            }
            Expr::Return { expr } => {
                if let Some(expr) = expr {
@@ -374,14 +370,14 @@ impl<'a> InferenceContext<'a> {
                    let unit = Ty::unit();
                    self.coerce(&unit, &self.return_ty.clone());
                }
-                Ty::simple(TypeCtor::Never)
+                Ty::Never
            }
            Expr::Yield { expr } => {
                // FIXME: track yield type for coercion
                if let Some(expr) = expr {
                    self.infer_expr(*expr, &Expectation::none());
                }
-                Ty::simple(TypeCtor::Never)
+                Ty::Never
            }
            Expr::RecordLit { path, fields, spread } => {
                let (ty, def_id) = self.resolve_variant(path.as_ref());
@@ -391,7 +387,7 @@ impl<'a> InferenceContext<'a> {
                self.unify(&ty, &expected.ty);
-                let substs = ty.substs().unwrap_or_else(Substs::empty);
+                let substs = ty.substs().cloned().unwrap_or_else(Substs::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_idx, field) in fields.iter().enumerate() {
@@ -430,30 +426,23 @@ impl<'a> InferenceContext<'a> {
                    },
                )
                .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
-                    Ty::Apply(a_ty) => match a_ty.ctor {
+                    Ty::Tuple(_, substs) => {
-                        TypeCtor::Tuple { .. } => name
+                        name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned())
-                            .as_tuple_index()
+                    }
-                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
+                    Ty::Adt(AdtId::StructId(s), parameters) => {
-                        TypeCtor::Adt(AdtId::StructId(s)) => {
+                        self.db.struct_data(s).variant_data.field(name).map(|local_id| {
-                            self.db.struct_data(s).variant_data.field(name).map(|local_id| {
+                            let field = FieldId { parent: s.into(), local_id };
-                                let field = FieldId { parent: s.into(), local_id };
+                            self.write_field_resolution(tgt_expr, field);
-                                self.write_field_resolution(tgt_expr, field);
+                            self.db.field_types(s.into())[field.local_id].clone().subst(&parameters)
-                                self.db.field_types(s.into())[field.local_id]
+                        })
-                                    .clone()
+                    }
-                                    .subst(&a_ty.parameters)
+                    Ty::Adt(AdtId::UnionId(u), parameters) => {
-                            })
+                        self.db.union_data(u).variant_data.field(name).map(|local_id| {
-                        }
+                            let field = FieldId { parent: u.into(), local_id };
-                        TypeCtor::Adt(AdtId::UnionId(u)) => {
+                            self.write_field_resolution(tgt_expr, field);
-                            self.db.union_data(u).variant_data.field(name).map(|local_id| {
+                            self.db.field_types(u.into())[field.local_id].clone().subst(&parameters)
-                                let field = FieldId { parent: u.into(), local_id };
+                        })
-                                self.write_field_resolution(tgt_expr, field);
+                    }
-                                self.db.field_types(u.into())[field.local_id]
-                                    .clone()
-                                    .subst(&a_ty.parameters)
-                            })
-                        }
-                        _ => None,
-                    },
                    _ => None,
                })
                .unwrap_or(Ty::Unknown);
@@ -475,10 +464,11 @@ impl<'a> InferenceContext<'a> {
                cast_ty
            }
            Expr::Ref { expr, rawness, mutability } => {
+                let mutability = lower_to_chalk_mutability(*mutability);
                let expectation = if let Some((exp_inner, exp_rawness, exp_mutability)) =
                    &expected.ty.as_reference_or_ptr()
                {
-                    if *exp_mutability == Mutability::Mut && *mutability == Mutability::Shared {
+                    if *exp_mutability == Mutability::Mut && mutability == Mutability::Not {
                        // FIXME: throw type error - expected mut reference but found shared ref,
                        // which cannot be coerced
                    }
@@ -491,19 +481,24 @@ impl<'a> InferenceContext<'a> {
                    Expectation::none()
                };
                let inner_ty = self.infer_expr_inner(*expr, &expectation);
-                let ty = match rawness {
+                match rawness {
-                    Rawness::RawPtr => TypeCtor::RawPtr(*mutability),
+                    Rawness::RawPtr => Ty::Raw(mutability, Substs::single(inner_ty)),
-                    Rawness::Ref => TypeCtor::Ref(*mutability),
+                    Rawness::Ref => Ty::Ref(mutability, Substs::single(inner_ty)),
-                };
+                }
-                Ty::apply_one(ty, inner_ty)
            }
            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::build_for_type_ctor(self.db, TypeCtor::Adt(box_));
+                    let mut sb = Substs::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() => {
+                            sb = sb.push(alloc_ty.value.clone());
+                        }
+                        _ => (),
+                    }
                    sb = sb.fill(repeat_with(|| self.table.new_type_var()));
-                    Ty::apply(TypeCtor::Adt(box_), sb.build())
+                    Ty::Adt(box_, sb.build())
                } else {
                    Ty::Unknown
                }
@@ -533,13 +528,11 @@ impl<'a> InferenceContext<'a> {
                    UnaryOp::Neg => {
                        match &inner_ty {
                            // Fast path for builtins
-                            Ty::Apply(ApplicationTy {
+                            Ty::Scalar(Scalar::Int(_))
-                                ctor: TypeCtor::Int(IntTy { signedness: Signedness::Signed, .. }),
+                            | Ty::Scalar(Scalar::Uint(_))
-                                ..
+                            | Ty::Scalar(Scalar::Float(_))
-                            })
+                            | Ty::InferenceVar(_, TyVariableKind::Integer)
-                            | Ty::Apply(ApplicationTy { ctor: TypeCtor::Float(_), .. })
+                            | Ty::InferenceVar(_, TyVariableKind::Float) => inner_ty,
-                            | Ty::Infer(InferTy::IntVar(..))
-                            | Ty::Infer(InferTy::FloatVar(..)) => inner_ty,
                            // Otherwise we resolve via the std::ops::Neg trait
                            _ => self
                                .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),
@@ -548,9 +541,10 @@ impl<'a> InferenceContext<'a> {
                    UnaryOp::Not => {
                        match &inner_ty {
                            // Fast path for builtins
-                            Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. })
+                            Ty::Scalar(Scalar::Bool)
-                            | Ty::Apply(ApplicationTy { ctor: TypeCtor::Int(_), .. })
+                            | Ty::Scalar(Scalar::Int(_))
-                            | Ty::Infer(InferTy::IntVar(..)) => inner_ty,
+                            | Ty::Scalar(Scalar::Uint(_))
+                            | Ty::InferenceVar(_, TyVariableKind::Integer) => inner_ty,
                            // Otherwise we resolve via the std::ops::Not trait
                            _ => self
                                .resolve_associated_type(inner_ty, self.resolve_ops_not_output()),
@@ -561,7 +555,7 @@ impl<'a> InferenceContext<'a> {
            Expr::BinaryOp { lhs, rhs, op } => match op {
                Some(op) => {
                    let lhs_expectation = match op {
-                        BinaryOp::LogicOp(..) => Expectation::has_type(Ty::simple(TypeCtor::Bool)),
+                        BinaryOp::LogicOp(..) => Expectation::has_type(Ty::Scalar(Scalar::Bool)),
                        _ => Expectation::none(),
                    };
                    let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
@@ -592,31 +586,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::simple(TypeCtor::Adt(adt)),
+                        Some(adt) => Ty::Adt(adt, Substs::empty()),
                        None => Ty::Unknown,
                    },
                    (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
-                        Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
+                        Some(adt) => Ty::Adt(adt, Substs::single(ty)),
                        None => Ty::Unknown,
                    },
                    (RangeOp::Inclusive, None, Some(ty)) => {
                        match self.resolve_range_to_inclusive() {
-                            Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
+                            Some(adt) => Ty::Adt(adt, Substs::single(ty)),
                            None => Ty::Unknown,
                        }
                    }
                    (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
-                        Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
+                        Some(adt) => Ty::Adt(adt, Substs::single(ty)),
                        None => Ty::Unknown,
                    },
                    (RangeOp::Inclusive, Some(_), Some(ty)) => {
                        match self.resolve_range_inclusive() {
-                            Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
+                            Some(adt) => Ty::Adt(adt, Substs::single(ty)),
                            None => Ty::Unknown,
                        }
                    }
                    (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
-                        Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
+                        Some(adt) => Ty::Adt(adt, Substs::single(ty)),
                        None => Ty::Unknown,
                    },
                    (RangeOp::Inclusive, _, None) => Ty::Unknown,
@@ -650,7 +644,7 @@ impl<'a> InferenceContext<'a> {
            }
            Expr::Tuple { exprs } => {
                let mut tys = match &expected.ty {
-                    ty_app!(TypeCtor::Tuple { .. }, st) => st
+                    Ty::Tuple(_, substs) => substs
                        .iter()
                        .cloned()
                        .chain(repeat_with(|| self.table.new_type_var()))
@@ -663,15 +657,11 @@ impl<'a> InferenceContext<'a> {
                    self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
                }
-                Ty::apply(TypeCtor::Tuple { cardinality: tys.len() as u16 }, Substs(tys.into()))
+                Ty::Tuple(tys.len(), Substs(tys.into()))
            }
            Expr::Array(array) => {
                let elem_ty = match &expected.ty {
-                    // FIXME: remove when https://github.com/rust-lang/rust/issues/80501 is fixed
+                    Ty::Array(st) | Ty::Slice(st) => st.as_single().clone(),
-                    #[allow(unreachable_patterns)]
-                    ty_app!(TypeCtor::Array, st) | ty_app!(TypeCtor::Slice, st) => {
-                        st.as_single().clone()
-                    }
                    _ => self.table.new_type_var(),
                };
@@ -688,30 +678,38 @@ impl<'a> InferenceContext<'a> {
                        );
                        self.infer_expr(
                            *repeat,
-                            &Expectation::has_type(Ty::simple(TypeCtor::Int(IntTy::usize()))),
+                            &Expectation::has_type(Ty::Scalar(Scalar::Uint(UintTy::Usize))),
                        );
                    }
                }
-                Ty::apply_one(TypeCtor::Array, elem_ty)
+                Ty::Array(Substs::single(elem_ty))
            }
            Expr::Literal(lit) => match lit {
-                Literal::Bool(..) => Ty::simple(TypeCtor::Bool),
+                Literal::Bool(..) => Ty::Scalar(Scalar::Bool),
-                Literal::String(..) => {
+                Literal::String(..) => Ty::Ref(Mutability::Not, Substs::single(Ty::Str)),
-                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
-                }
                Literal::ByteString(..) => {
-                    let byte_type = Ty::simple(TypeCtor::Int(IntTy::u8()));
+                    let byte_type = Ty::Scalar(Scalar::Uint(UintTy::U8));
-                    let array_type = Ty::apply_one(TypeCtor::Array, byte_type);
+                    let array_type = Ty::Array(Substs::single(byte_type));
-                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), array_type)
+                    Ty::Ref(Mutability::Not, Substs::single(array_type))
                }
-                Literal::Char(..) => Ty::simple(TypeCtor::Char),
+                Literal::Char(..) => Ty::Scalar(Scalar::Char),
                Literal::Int(_v, ty) => match ty {
-                    Some(int_ty) => Ty::simple(TypeCtor::Int((*int_ty).into())),
+                    Some(int_ty) => {
+                        Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty)))
+                    }
+                    None => self.table.new_integer_var(),
+                },
+                Literal::Uint(_v, ty) => match ty {
+                    Some(int_ty) => {
+                        Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty)))
+                    }
                    None => self.table.new_integer_var(),
                },
                Literal::Float(_v, ty) => match ty {
-                    Some(float_ty) => Ty::simple(TypeCtor::Float((*float_ty).into())),
+                    Some(float_ty) => {
+                        Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty)))
+                    }
                    None => self.table.new_float_var(),
                },
            },
@@ -767,7 +765,7 @@ impl<'a> InferenceContext<'a> {
            // `!`).
            if self.diverges.is_always() {
                // we don't even make an attempt at coercion
-                self.table.new_maybe_never_type_var()
+                self.table.new_maybe_never_var()
            } else {
                self.coerce(&Ty::unit(), expected.coercion_target());
                Ty::unit()
@@ -824,7 +822,7 @@ impl<'a> InferenceContext<'a> {
        // Apply autoref so the below unification works correctly
        // FIXME: return correct autorefs from lookup_method
        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
-            Some((_, mutability)) => Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty),
+            Some((_, mutability)) => Ty::Ref(mutability, Substs::single(derefed_receiver_ty)),
            _ => derefed_receiver_ty,
        };
        self.unify(&expected_receiver_ty, &actual_receiver_ty);
@@ -901,30 +899,26 @@ impl<'a> InferenceContext<'a> {
    }
    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
-        if let Ty::Apply(a_ty) = callable_ty {
+        if let &Ty::FnDef(def, ref parameters) = callable_ty {
-            if let TypeCtor::FnDef(def) = a_ty.ctor {
+            let generic_predicates = self.db.generic_predicates(def.into());
-                let generic_predicates = self.db.generic_predicates(def.into());
+            for predicate in generic_predicates.iter() {
-                for predicate in generic_predicates.iter() {
+                let predicate = predicate.clone().subst(parameters);
-                    let predicate = predicate.clone().subst(&a_ty.parameters);
+                if let Some(obligation) = Obligation::from_predicate(predicate) {
-                    if let Some(obligation) = Obligation::from_predicate(predicate) {
+                    self.obligations.push(obligation);
-                        self.obligations.push(obligation);
-                    }
                }
-                // add obligation for trait implementation, if this is a trait method
+            }
-                match def {
+            // add obligation for trait implementation, if this is a trait method
-                    CallableDefId::FunctionId(f) => {
+            match def {
-                        if let AssocContainerId::TraitId(trait_) =
+                CallableDefId::FunctionId(f) => {
-                            f.lookup(self.db.upcast()).container
+                    if let AssocContainerId::TraitId(trait_) = f.lookup(self.db.upcast()).container
-                        {
+                    {
-                            // construct a TraitDef
+                        // construct a TraitDef
-                            let substs = a_ty
+                        let substs =
-                                .parameters
+                            parameters.prefix(generics(self.db.upcast(), trait_.into()).len());
-                                .prefix(generics(self.db.upcast(), trait_.into()).len());
+                        self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
-                            self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
-                        }
                    }
-                    CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {}
                }
+                CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {}
            }
        }
    }
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index d974f805b..eb099311c 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -3,17 +3,17 @@
 use std::iter::repeat;
 use std::sync::Arc;
+use chalk_ir::Mutability;
 use hir_def::{
    expr::{BindingAnnotation, Expr, Literal, Pat, PatId, RecordFieldPat},
    path::Path,
-    type_ref::Mutability,
    FieldId,
 };
 use hir_expand::name::Name;
 use test_utils::mark;
 use super::{BindingMode, Expectation, InferenceContext};
-use crate::{utils::variant_data, Substs, Ty, TypeCtor};
+use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Substs, Ty};
 impl<'a> InferenceContext<'a> {
    fn infer_tuple_struct_pat(
@@ -32,7 +32,7 @@ impl<'a> InferenceContext<'a> {
        }
        self.unify(&ty, expected);
-        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        let (pre, post) = match ellipsis {
@@ -71,7 +71,7 @@ impl<'a> InferenceContext<'a> {
        self.unify(&ty, expected);
-        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        for subpat in subpats {
@@ -103,7 +103,7 @@ impl<'a> InferenceContext<'a> {
                expected = inner;
                default_bm = match default_bm {
                    BindingMode::Move => BindingMode::Ref(mutability),
-                    BindingMode::Ref(Mutability::Shared) => BindingMode::Ref(Mutability::Shared),
+                    BindingMode::Ref(Mutability::Not) => BindingMode::Ref(Mutability::Not),
                    BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(mutability),
                }
            }
@@ -138,10 +138,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));
-                Ty::apply(
+                Ty::Tuple(inner_tys.len(), Substs(inner_tys.into()))
-                    TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
-                    Substs(inner_tys.into()),
-                )
            }
            Pat::Or(ref pats) => {
                if let Some((first_pat, rest)) = pats.split_first() {
@@ -155,9 +152,10 @@ impl<'a> InferenceContext<'a> {
                }
            }
            Pat::Ref { pat, mutability } => {
+                let mutability = lower_to_chalk_mutability(*mutability);
                let expectation = match expected.as_reference() {
                    Some((inner_ty, exp_mut)) => {
-                        if *mutability != exp_mut {
+                        if mutability != exp_mut {
                            // FIXME: emit type error?
                        }
                        inner_ty
@@ -165,7 +163,7 @@ impl<'a> InferenceContext<'a> {
                    _ => &Ty::Unknown,
                };
                let subty = self.infer_pat(*pat, expectation, default_bm);
-                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
+                Ty::Ref(mutability, Substs::single(subty))
            }
            Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
                p.as_ref(),
@@ -198,7 +196,7 @@ impl<'a> InferenceContext<'a> {
                let bound_ty = match mode {
                    BindingMode::Ref(mutability) => {
-                        Ty::apply_one(TypeCtor::Ref(mutability), inner_ty.clone())
+                        Ty::Ref(mutability, Substs::single(inner_ty.clone()))
                    }
                    BindingMode::Move => inner_ty.clone(),
                };
@@ -207,17 +205,17 @@ impl<'a> InferenceContext<'a> {
                return inner_ty;
            }
            Pat::Slice { prefix, slice, suffix } => {
-                let (container_ty, elem_ty) = match &expected {
+                let (container_ty, elem_ty): (fn(_) -> _, _) = match &expected {
-                    ty_app!(TypeCtor::Array, st) => (TypeCtor::Array, st.as_single().clone()),
+                    Ty::Array(st) => (Ty::Array, st.as_single().clone()),
-                    ty_app!(TypeCtor::Slice, st) => (TypeCtor::Slice, st.as_single().clone()),
+                    Ty::Slice(st) => (Ty::Slice, st.as_single().clone()),
-                    _ => (TypeCtor::Slice, Ty::Unknown),
+                    _ => (Ty::Slice, Ty::Unknown),
                };
                for pat_id in prefix.iter().chain(suffix) {
                    self.infer_pat(*pat_id, &elem_ty, default_bm);
                }
-                let pat_ty = Ty::apply_one(container_ty, elem_ty);
+                let pat_ty = container_ty(Substs::single(elem_ty));
                if let Some(slice_pat_id) = slice {
                    self.infer_pat(*slice_pat_id, &pat_ty, default_bm);
                }
@@ -239,7 +237,7 @@ impl<'a> InferenceContext<'a> {
                    };
                    let inner_ty = self.infer_pat(*inner, inner_expected, default_bm);
-                    Ty::apply_one(TypeCtor::Adt(box_adt), inner_ty)
+                    Ty::Adt(box_adt, Substs::single(inner_ty))
                }
                None => Ty::Unknown,
            },
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 76984242e..99a89a7f3 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -2,14 +2,15 @@
 use std::borrow::Cow;
+use chalk_ir::{FloatTy, IntTy, TyVariableKind};
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use test_utils::mark;
 use super::{InferenceContext, Obligation};
 use crate::{
-    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferTy, Substs, Ty,
+    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Scalar,
-    TyKind, TypeCtor, TypeWalk,
+    Substs, Ty, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -26,7 +27,7 @@ where
    'a: 'b,
 {
    ctx: &'b mut InferenceContext<'a>,
-    free_vars: Vec<InferTy>,
+    free_vars: Vec<(InferenceVar, TyVariableKind)>,
    /// A stack of type variables that is used to detect recursive types (which
    /// are an error, but we need to protect against them to avoid stack
    /// overflows).
@@ -36,17 +37,14 @@ where
 #[derive(Debug)]
 pub(super) struct Canonicalized<T> {
    pub(super) value: Canonical<T>,
-    free_vars: Vec<InferTy>,
+    free_vars: Vec<(InferenceVar, TyVariableKind)>,
 }
-impl<'a, 'b> Canonicalizer<'a, 'b>
+impl<'a, 'b> Canonicalizer<'a, 'b> {
-where
+    fn add(&mut self, free_var: InferenceVar, kind: TyVariableKind) -> usize {
-    'a: 'b,
+        self.free_vars.iter().position(|&(v, _)| v == free_var).unwrap_or_else(|| {
-{
-    fn add(&mut self, free_var: InferTy) -> usize {
-        self.free_vars.iter().position(|&v| v == free_var).unwrap_or_else(|| {
            let next_index = self.free_vars.len();
-            self.free_vars.push(free_var);
+            self.free_vars.push((free_var, kind));
            next_index
        })
    }
@@ -54,11 +52,11 @@ where
    fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T {
        t.fold_binders(
            &mut |ty, binders| match ty {
-                Ty::Infer(tv) => {
+                Ty::InferenceVar(var, kind) => {
-                    let inner = tv.to_inner();
+                    let inner = var.to_inner();
                    if self.var_stack.contains(&inner) {
                        // recursive type
-                        return tv.fallback_value();
+                        return self.ctx.table.type_variable_table.fallback_value(var, kind);
                    }
                    if let Some(known_ty) =
                        self.ctx.table.var_unification_table.inlined_probe_value(inner).known()
@@ -69,14 +67,8 @@ where
                        result
                    } else {
                        let root = self.ctx.table.var_unification_table.find(inner);
-                        let free_var = match tv {
+                        let position = self.add(InferenceVar::from_inner(root), kind);
-                            InferTy::TypeVar(_) => InferTy::TypeVar(root),
+                        Ty::BoundVar(BoundVar::new(binders, position))
-                            InferTy::IntVar(_) => InferTy::IntVar(root),
-                            InferTy::FloatVar(_) => InferTy::FloatVar(root),
-                            InferTy::MaybeNeverTypeVar(_) => InferTy::MaybeNeverTypeVar(root),
-                        };
-                        let position = self.add(free_var);
-                        Ty::Bound(BoundVar::new(binders, position))
                    }
                }
                _ => ty,
@@ -86,19 +78,7 @@ where
    }
    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
-        let kinds = self
+        let kinds = self.free_vars.iter().map(|&(_, k)| k).collect();
-            .free_vars
-            .iter()
-            .map(|v| match v {
-                // mapping MaybeNeverTypeVar to the same kind as general ones
-                // should be fine, because as opposed to int or float type vars,
-                // they don't restrict what kind of type can go into them, they
-                // just affect fallback.
-                InferTy::TypeVar(_) | InferTy::MaybeNeverTypeVar(_) => TyKind::General,
-                InferTy::IntVar(_) => TyKind::Integer,
-                InferTy::FloatVar(_) => TyKind::Float,
-            })
-            .collect();
        Canonicalized { value: Canonical { value: result, kinds }, free_vars: self.free_vars }
    }
@@ -130,9 +110,10 @@ impl<T> Canonicalized<T> {
    pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
        ty.walk_mut_binders(
            &mut |ty, binders| {
-                if let &mut Ty::Bound(bound) = ty {
+                if let &mut Ty::BoundVar(bound) = ty {
                    if bound.debruijn >= binders {
-                        *ty = Ty::Infer(self.free_vars[bound.index]);
+                        let (v, k) = self.free_vars[bound.index];
+                        *ty = Ty::InferenceVar(v, k);
                    }
                }
            },
@@ -152,18 +133,18 @@ impl<T> Canonicalized<T> {
                .kinds
                .iter()
                .map(|k| match k {
-                    TyKind::General => ctx.table.new_type_var(),
+                    TyVariableKind::General => ctx.table.new_type_var(),
-                    TyKind::Integer => ctx.table.new_integer_var(),
+                    TyVariableKind::Integer => ctx.table.new_integer_var(),
-                    TyKind::Float => ctx.table.new_float_var(),
+                    TyVariableKind::Float => ctx.table.new_float_var(),
                })
                .collect(),
        );
        for (i, ty) in solution.value.into_iter().enumerate() {
-            let var = self.free_vars[i];
+            let (v, k) = self.free_vars[i];
            // eagerly replace projections in the type; we may be getting types
            // e.g. from where clauses where this hasn't happened yet
            let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars));
-            ctx.table.unify(&Ty::Infer(var), &ty);
+            ctx.table.unify(&Ty::InferenceVar(v, k), &ty);
        }
    }
 }
@@ -187,7 +168,7 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
    // (kind of hacky)
    for (i, var) in vars.iter().enumerate() {
        if &*table.resolve_ty_shallow(var) == var {
-            table.unify(var, &Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, i)));
+            table.unify(var, &Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i)));
        }
    }
    Some(
@@ -198,31 +179,73 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
 }
 #[derive(Clone, Debug)]
+pub(super) struct TypeVariableTable {
+    inner: Vec<TypeVariableData>,
+}
+impl TypeVariableTable {
+    fn push(&mut self, data: TypeVariableData) {
+        self.inner.push(data);
+    }
+    pub(super) fn set_diverging(&mut self, iv: InferenceVar, diverging: bool) {
+        self.inner[iv.to_inner().0 as usize].diverging = diverging;
+    }
+    fn is_diverging(&mut self, iv: InferenceVar) -> bool {
+        self.inner[iv.to_inner().0 as usize].diverging
+    }
+    fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
+        match kind {
+            _ if self.inner[iv.to_inner().0 as usize].diverging => Ty::Never,
+            TyVariableKind::General => Ty::Unknown,
+            TyVariableKind::Integer => Ty::Scalar(Scalar::Int(IntTy::I32)),
+            TyVariableKind::Float => Ty::Scalar(Scalar::Float(FloatTy::F64)),
+        }
+    }
+}
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct TypeVariableData {
+    diverging: bool,
+}
+#[derive(Clone, Debug)]
 pub(crate) struct InferenceTable {
    pub(super) var_unification_table: InPlaceUnificationTable<TypeVarId>,
+    pub(super) type_variable_table: TypeVariableTable,
 }
 impl InferenceTable {
    pub(crate) fn new() -> Self {
-        InferenceTable { var_unification_table: InPlaceUnificationTable::new() }
+        InferenceTable {
+            var_unification_table: InPlaceUnificationTable::new(),
+            type_variable_table: TypeVariableTable { inner: Vec::new() },
+        }
+    }
+    fn new_var(&mut self, kind: TyVariableKind, diverging: bool) -> Ty {
+        self.type_variable_table.push(TypeVariableData { diverging });
+        let key = self.var_unification_table.new_key(TypeVarValue::Unknown);
+        assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1);
+        Ty::InferenceVar(InferenceVar::from_inner(key), kind)
    }
    pub(crate) fn new_type_var(&mut self) -> Ty {
-        Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
+        self.new_var(TyVariableKind::General, false)
    }
    pub(crate) fn new_integer_var(&mut self) -> Ty {
-        Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
+        self.new_var(TyVariableKind::Integer, false)
    }
    pub(crate) fn new_float_var(&mut self) -> Ty {
-        Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
+        self.new_var(TyVariableKind::Float, false)
    }
-    pub(crate) fn new_maybe_never_type_var(&mut self) -> Ty {
+    pub(crate) fn new_maybe_never_var(&mut self) -> Ty {
-        Ty::Infer(InferTy::MaybeNeverTypeVar(
+        self.new_var(TyVariableKind::General, true)
-            self.var_unification_table.new_key(TypeVarValue::Unknown),
-        ))
    }
    pub(crate) fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
@@ -257,12 +280,14 @@ impl InferenceTable {
        // try to resolve type vars first
        let ty1 = self.resolve_ty_shallow(ty1);
        let ty2 = self.resolve_ty_shallow(ty2);
-        match (&*ty1, &*ty2) {
+        if ty1.equals_ctor(&ty2) {
-            (Ty::Apply(a_ty1), Ty::Apply(a_ty2)) if a_ty1.ctor == a_ty2.ctor => {
+            match (ty1.substs(), ty2.substs()) {
-                self.unify_substs(&a_ty1.parameters, &a_ty2.parameters, depth + 1)
+                (Some(st1), Some(st2)) => self.unify_substs(st1, st2, depth + 1),
+                (None, None) => true,
+                _ => false,
            }
+        } else {
-            _ => self.unify_inner_trivial(&ty1, &ty2, depth),
+            self.unify_inner_trivial(&ty1, &ty2, depth)
        }
    }
@@ -281,31 +306,46 @@ impl InferenceTable {
                true
            }
-            (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2)))
+            (
-            | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2)))
+                Ty::InferenceVar(tv1, TyVariableKind::General),
-            | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2)))
+                Ty::InferenceVar(tv2, TyVariableKind::General),
+            )
            | (
-                Ty::Infer(InferTy::MaybeNeverTypeVar(tv1)),
+                Ty::InferenceVar(tv1, TyVariableKind::Integer),
-                Ty::Infer(InferTy::MaybeNeverTypeVar(tv2)),
+                Ty::InferenceVar(tv2, TyVariableKind::Integer),
-            ) => {
+            )
+            | (
+                Ty::InferenceVar(tv1, TyVariableKind::Float),
+                Ty::InferenceVar(tv2, TyVariableKind::Float),
+            ) if self.type_variable_table.is_diverging(*tv1)
+                == self.type_variable_table.is_diverging(*tv2) =>
+            {
                // both type vars are unknown since we tried to resolve them
-                self.var_unification_table.union(*tv1, *tv2);
+                self.var_unification_table.union(tv1.to_inner(), tv2.to_inner());
                true
            }
            // The order of MaybeNeverTypeVar matters here.
            // Unifying MaybeNeverTypeVar and TypeVar will let the latter become MaybeNeverTypeVar.
            // Unifying MaybeNeverTypeVar and other concrete type will let the former become it.
-            (Ty::Infer(InferTy::TypeVar(tv)), other)
+            (Ty::InferenceVar(tv, TyVariableKind::General), other)
-            | (other, Ty::Infer(InferTy::TypeVar(tv)))
+            | (other, Ty::InferenceVar(tv, TyVariableKind::General))
-            | (Ty::Infer(InferTy::MaybeNeverTypeVar(tv)), other)
+            | (Ty::InferenceVar(tv, TyVariableKind::Integer), other @ Ty::Scalar(Scalar::Int(_)))
-            | (other, Ty::Infer(InferTy::MaybeNeverTypeVar(tv)))
+            | (other @ Ty::Scalar(Scalar::Int(_)), Ty::InferenceVar(tv, TyVariableKind::Integer))
-            | (Ty::Infer(InferTy::IntVar(tv)), other @ ty_app!(TypeCtor::Int(_)))
+            | (
-            | (other @ ty_app!(TypeCtor::Int(_)), Ty::Infer(InferTy::IntVar(tv)))
+                Ty::InferenceVar(tv, TyVariableKind::Integer),
-            | (Ty::Infer(InferTy::FloatVar(tv)), other @ ty_app!(TypeCtor::Float(_)))
+                other @ Ty::Scalar(Scalar::Uint(_)),
-            | (other @ ty_app!(TypeCtor::Float(_)), Ty::Infer(InferTy::FloatVar(tv))) => {
+            )
+            | (
+                other @ Ty::Scalar(Scalar::Uint(_)),
+                Ty::InferenceVar(tv, TyVariableKind::Integer),
+            )
+            | (Ty::InferenceVar(tv, TyVariableKind::Float), other @ Ty::Scalar(Scalar::Float(_)))
+            | (other @ Ty::Scalar(Scalar::Float(_)), Ty::InferenceVar(tv, TyVariableKind::Float)) =>
+            {
                // the type var is unknown since we tried to resolve it
-                self.var_unification_table.union_value(*tv, TypeVarValue::Known(other.clone()));
+                self.var_unification_table
+                    .union_value(tv.to_inner(), TypeVarValue::Known(other.clone()));
                true
            }
@@ -350,7 +390,7 @@ impl InferenceTable {
                mark::hit!(type_var_resolves_to_int_var);
            }
            match &*ty {
-                Ty::Infer(tv) => {
+                Ty::InferenceVar(tv, _) => {
                    let inner = tv.to_inner();
                    match self.var_unification_table.inlined_probe_value(inner).known() {
                        Some(known_ty) => {
@@ -373,12 +413,12 @@ impl InferenceTable {
    /// known type.
    fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
        ty.fold(&mut |ty| match ty {
-            Ty::Infer(tv) => {
+            Ty::InferenceVar(tv, kind) => {
                let inner = tv.to_inner();
                if tv_stack.contains(&inner) {
                    mark::hit!(type_var_cycles_resolve_as_possible);
                    // recursive type
-                    return tv.fallback_value();
+                    return self.type_variable_table.fallback_value(tv, kind);
                }
                if let Some(known_ty) =
                    self.var_unification_table.inlined_probe_value(inner).known()
@@ -400,12 +440,12 @@ impl InferenceTable {
    /// replaced by Ty::Unknown.
    fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
        ty.fold(&mut |ty| match ty {
-            Ty::Infer(tv) => {
+            Ty::InferenceVar(tv, kind) => {
                let inner = tv.to_inner();
                if tv_stack.contains(&inner) {
                    mark::hit!(type_var_cycles_resolve_completely);
                    // recursive type
-                    return tv.fallback_value();
+                    return self.type_variable_table.fallback_value(tv, kind);
                }
                if let Some(known_ty) =
                    self.var_unification_table.inlined_probe_value(inner).known()
@@ -416,7 +456,7 @@ impl InferenceTable {
                    tv_stack.pop();
                    result
                } else {
-                    tv.fallback_value()
+                    self.type_variable_table.fallback_value(tv, kind)
                }
            }
            _ => ty,
@@ -426,7 +466,7 @@ impl InferenceTable {
 /// The ID of a type variable.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub struct TypeVarId(pub(super) u32);
+pub(super) struct TypeVarId(pub(super) u32);
 impl UnifyKey for TypeVarId {
    type Value = TypeVarValue;
@@ -447,7 +487,7 @@ impl UnifyKey for TypeVarId {
 /// The value of a type variable: either we already know the type, or we don't
 /// know it yet.
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub enum TypeVarValue {
+pub(super) enum TypeVarValue {
    Known(Ty),
    Unknown,
 }
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 50d248674..c2a20c480 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -25,32 +25,29 @@ mod test_db;
 use std::{iter, mem, ops::Deref, sync::Arc};
-use base_db::{salsa, CrateId};
+use base_db::salsa;
 use hir_def::{
-    builtin_type::BuiltinType,
+    builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AdtId, AssocContainerId,
-    expr::ExprId,
+    DefWithBodyId, FunctionId, GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId,
-    type_ref::{Mutability, Rawness},
+    TypeAliasId, TypeParamId,
-    AdtId, AssocContainerId, DefWithBodyId, FunctionId, GenericDefId, HasModule, LifetimeParamId,
-    Lookup, TraitId, TypeAliasId, TypeParamId,
 };
 use itertools::Itertools;
 use crate::{
    db::HirDatabase,
    display::HirDisplay,
-    primitive::{FloatTy, IntTy},
    utils::{generics, make_mut_slice, Generics},
 };
 pub use autoderef::autoderef;
-pub use infer::{InferTy, InferenceResult};
+pub use infer::{InferenceResult, InferenceVar};
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
 };
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
-pub use chalk_ir::{BoundVar, DebruijnIndex};
+pub use chalk_ir::{BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind};
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Lifetime {
@@ -58,211 +55,6 @@ pub enum Lifetime {
    Static,
 }
-/// A type constructor or type name: this might be something like the primitive
-/// type `bool`, a struct like `Vec`, or things like function pointers or
-/// tuples.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-pub enum TypeCtor {
-    /// The primitive boolean type. Written as `bool`.
-    Bool,
-    /// The primitive character type; holds a Unicode scalar value
-    /// (a non-surrogate code point). Written as `char`.
-    Char,
-    /// A primitive integer type. For example, `i32`.
-    Int(IntTy),
-    /// A primitive floating-point type. For example, `f64`.
-    Float(FloatTy),
-    /// Structures, enumerations and unions.
-    Adt(AdtId),
-    /// The pointee of a string slice. Written as `str`.
-    Str,
-    /// The pointee of an array slice.  Written as `[T]`.
-    Slice,
-    /// An array with the given length. Written as `[T; n]`.
-    Array,
-    /// A raw pointer. Written as `*mut T` or `*const T`
-    RawPtr(Mutability),
-    /// A reference; a pointer with an associated lifetime. Written as
-    /// `&'a mut T` or `&'a T`.
-    Ref(Mutability),
-    /// The anonymous type of a function declaration/definition. Each
-    /// function has a unique type, which is output (for a function
-    /// named `foo` returning an `i32`) as `fn() -> i32 {foo}`.
-    ///
-    /// This includes tuple struct / enum variant constructors as well.
-    ///
-    /// For example the type of `bar` here:
-    ///
-    /// ```
-    /// fn foo() -> i32 { 1 }
-    /// let bar = foo; // bar: fn() -> i32 {foo}
-    /// ```
-    FnDef(CallableDefId),
-    /// A pointer to a function.  Written as `fn() -> i32`.
-    ///
-    /// For example the type of `bar` here:
-    ///
-    /// ```
-    /// fn foo() -> i32 { 1 }
-    /// let bar: fn() -> i32 = foo;
-    /// ```
-    // FIXME make this a Ty variant like in Chalk
-    FnPtr { num_args: u16, is_varargs: bool },
-    /// The never type `!`.
-    Never,
-    /// A tuple type.  For example, `(i32, bool)`.
-    Tuple { cardinality: u16 },
-    /// 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(TypeAliasId),
-    /// This represents a placeholder for an opaque type in situations where we
-    /// don't know the hidden type (i.e. currently almost always). This is
-    /// 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),
-    /// Represents a foreign type declared in external blocks.
-    ForeignType(TypeAliasId),
-    /// The type of a specific closure.
-    ///
-    /// The closure signature is stored in a `FnPtr` type in the first type
-    /// parameter.
-    Closure { def: DefWithBodyId, expr: ExprId },
-}
-impl TypeCtor {
-    pub fn num_ty_params(self, db: &dyn HirDatabase) -> usize {
-        match self {
-            TypeCtor::Bool
-            | TypeCtor::Char
-            | TypeCtor::Int(_)
-            | TypeCtor::Float(_)
-            | TypeCtor::Str
-            | TypeCtor::Never => 0,
-            TypeCtor::Slice
-            | TypeCtor::Array
-            | TypeCtor::RawPtr(_)
-            | TypeCtor::Ref(_)
-            | TypeCtor::Closure { .. } // 1 param representing the signature of the closure
-            => 1,
-            TypeCtor::Adt(adt) => {
-                let generic_params = generics(db.upcast(), adt.into());
-                generic_params.len()
-            }
-            TypeCtor::FnDef(callable) => {
-                let generic_params = generics(db.upcast(), callable.into());
-                generic_params.len()
-            }
-            TypeCtor::AssociatedType(type_alias) => {
-                let generic_params = generics(db.upcast(), type_alias.into());
-                generic_params.len()
-            }
-            TypeCtor::ForeignType(type_alias) => {
-                let generic_params = generics(db.upcast(), type_alias.into());
-                generic_params.len()
-            }
-            TypeCtor::OpaqueType(opaque_ty_id) => {
-                match opaque_ty_id {
-                    OpaqueTyId::ReturnTypeImplTrait(func, _) => {
-                        let generic_params = generics(db.upcast(), func.into());
-                        generic_params.len()
-                    }
-                    // 1 param representing Future::Output type.
-                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => 1,
-                }
-            }
-            TypeCtor::FnPtr { num_args, is_varargs: _ } => num_args as usize + 1,
-            TypeCtor::Tuple { cardinality } => cardinality as usize,
-        }
-    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<CrateId> {
-        match self {
-            TypeCtor::Bool
-            | TypeCtor::Char
-            | TypeCtor::Int(_)
-            | TypeCtor::Float(_)
-            | TypeCtor::Str
-            | TypeCtor::Never
-            | TypeCtor::Slice
-            | TypeCtor::Array
-            | TypeCtor::RawPtr(_)
-            | TypeCtor::Ref(_)
-            | TypeCtor::FnPtr { .. }
-            | TypeCtor::Tuple { .. } => None,
-            // Closure's krate is irrelevant for coherence I would think?
-            TypeCtor::Closure { .. } => None,
-            TypeCtor::Adt(adt) => Some(adt.module(db.upcast()).krate()),
-            TypeCtor::FnDef(callable) => Some(callable.krate(db)),
-            TypeCtor::AssociatedType(type_alias) => {
-                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate())
-            }
-            TypeCtor::ForeignType(type_alias) => {
-                Some(type_alias.lookup(db.upcast()).module(db.upcast()).krate())
-            }
-            TypeCtor::OpaqueType(opaque_ty_id) => match opaque_ty_id {
-                OpaqueTyId::ReturnTypeImplTrait(func, _) => {
-                    Some(func.lookup(db.upcast()).module(db.upcast()).krate())
-                }
-                OpaqueTyId::AsyncBlockTypeImplTrait(def, _) => {
-                    Some(def.module(db.upcast()).krate())
-                }
-            },
-        }
-    }
-    pub fn as_generic_def(self) -> Option<GenericDefId> {
-        match self {
-            TypeCtor::Bool
-            | TypeCtor::Char
-            | TypeCtor::Int(_)
-            | TypeCtor::Float(_)
-            | TypeCtor::Str
-            | TypeCtor::Never
-            | TypeCtor::Slice
-            | TypeCtor::Array
-            | TypeCtor::RawPtr(_)
-            | TypeCtor::Ref(_)
-            | TypeCtor::FnPtr { .. }
-            | TypeCtor::Tuple { .. }
-            | TypeCtor::Closure { .. } => None,
-            TypeCtor::Adt(adt) => Some(adt.into()),
-            TypeCtor::FnDef(callable) => Some(callable.into()),
-            TypeCtor::AssociatedType(type_alias) => Some(type_alias.into()),
-            TypeCtor::ForeignType(type_alias) => Some(type_alias.into()),
-            TypeCtor::OpaqueType(_impl_trait_id) => None,
-        }
-    }
-}
-/// A nominal type with (maybe 0) type parameters. This might be a primitive
-/// type like `bool`, a struct, tuple, function pointer, reference or
-/// several other things.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct ApplicationTy {
-    pub ctor: TypeCtor,
-    pub parameters: Substs,
-}
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct OpaqueTy {
    pub opaque_ty_id: OpaqueTyId,
@@ -305,29 +97,118 @@ impl TypeWalk for ProjectionTy {
    }
 }
-/// A type.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-///
+pub struct FnSig {
-/// See also the `TyKind` enum in rustc (librustc/ty/sty.rs), which represents
+    pub variadic: bool,
-/// the same thing (but in a different way).
+}
-///
-/// This should be cheap to clone.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub enum Ty {
+pub struct FnPointer {
-    /// A nominal type with (maybe 0) type parameters. This might be a primitive
+    pub num_args: usize,
-    /// type like `bool`, a struct, tuple, function pointer, reference or
+    pub sig: FnSig,
-    /// several other things.
+    pub substs: Substs,
-    Apply(ApplicationTy),
+}
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub enum AliasTy {
    /// A "projection" type corresponds to an (unnormalized)
    /// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
    /// trait and all its parameters are fully known.
    Projection(ProjectionTy),
    /// An opaque type (`impl Trait`).
    ///
    /// This is currently only used for return type impl trait; each instance of
    /// `impl Trait` in a return type gets its own ID.
    Opaque(OpaqueTy),
+}
+/// A type.
+///
+/// See also the `TyKind` enum in rustc (librustc/ty/sty.rs), which represents
+/// the same thing (but in a different way).
+///
+/// This should be cheap to clone.
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub enum Ty {
+    /// Structures, enumerations and unions.
+    Adt(AdtId, Substs),
+    /// 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(TypeAliasId, Substs),
+    /// a scalar type like `bool` or `u32`
+    Scalar(Scalar),
+    /// A tuple type.  For example, `(i32, bool)`.
+    Tuple(usize, Substs),
+    /// An array with the given length. Written as `[T; n]`.
+    Array(Substs),
+    /// The pointee of an array slice.  Written as `[T]`.
+    Slice(Substs),
+    /// A raw pointer. Written as `*mut T` or `*const T`
+    Raw(Mutability, Substs),
+    /// A reference; a pointer with an associated lifetime. Written as
+    /// `&'a mut T` or `&'a T`.
+    Ref(Mutability, Substs),
+    /// This represents a placeholder for an opaque type in situations where we
+    /// don't know the hidden type (i.e. currently almost always). This is
+    /// 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),
+    /// The anonymous type of a function declaration/definition. Each
+    /// function has a unique type, which is output (for a function
+    /// named `foo` returning an `i32`) as `fn() -> i32 {foo}`.
+    ///
+    /// This includes tuple struct / enum variant constructors as well.
+    ///
+    /// For example the type of `bar` here:
+    ///
+    /// ```
+    /// fn foo() -> i32 { 1 }
+    /// let bar = foo; // bar: fn() -> i32 {foo}
+    /// ```
+    FnDef(CallableDefId, Substs),
+    /// The pointee of a string slice. Written as `str`.
+    Str,
+    /// The never type `!`.
+    Never,
+    /// The type of a specific closure.
+    ///
+    /// The closure signature is stored in a `FnPtr` type in the first type
+    /// parameter.
+    Closure(DefWithBodyId, ExprId, Substs),
+    /// Represents a foreign type declared in external blocks.
+    ForeignType(TypeAliasId),
+    /// A pointer to a function.  Written as `fn() -> i32`.
+    ///
+    /// For example the type of `bar` here:
+    ///
+    /// ```
+    /// fn foo() -> i32 { 1 }
+    /// let bar: fn() -> i32 = foo;
+    /// ```
+    Function(FnPointer),
+    /// An "alias" type represents some form of type alias, such as:
+    /// - An associated type projection like `<T as Iterator>::Item`
+    /// - `impl Trait` types
+    /// - Named type aliases like `type Foo<X> = Vec<X>`
+    Alias(AliasTy),
    /// A placeholder for a type parameter; for example, `T` in `fn f<T>(x: T)
    /// {}` when we're type-checking the body of that function. In this
@@ -340,10 +221,10 @@ pub enum Ty {
    /// parameters get turned into variables; during trait resolution, inference
    /// variables get turned into bound variables and back; and in `Dyn` the
    /// `Self` type is represented with a bound variable as well.
-    Bound(BoundVar),
+    BoundVar(BoundVar),
    /// A type variable used during type checking.
-    Infer(InferTy),
+    InferenceVar(InferenceVar, TyVariableKind),
    /// A trait object (`dyn Trait` or bare `Trait` in pre-2018 Rust).
    ///
@@ -424,7 +305,7 @@ impl Substs {
            generic_params
                .iter()
                .enumerate()
-                .map(|(idx, _)| Ty::Bound(BoundVar::new(debruijn, idx)))
+                .map(|(idx, _)| Ty::BoundVar(BoundVar::new(debruijn, idx)))
                .collect(),
        )
    }
@@ -440,10 +321,6 @@ impl Substs {
        Substs::builder(generic_params.len())
    }
-    pub fn build_for_type_ctor(db: &dyn HirDatabase, type_ctor: TypeCtor) -> SubstsBuilder {
-        Substs::builder(type_ctor.num_ty_params(db))
-    }
    fn builder(param_count: usize) -> SubstsBuilder {
        SubstsBuilder { vec: Vec::with_capacity(param_count), param_count }
    }
@@ -476,7 +353,7 @@ impl SubstsBuilder {
    }
    pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self {
-        self.fill((starting_from..).map(|idx| Ty::Bound(BoundVar::new(debruijn, idx))))
+        self.fill((starting_from..).map(|idx| Ty::BoundVar(BoundVar::new(debruijn, idx))))
    }
    pub fn fill_with_unknown(self) -> Self {
@@ -656,41 +533,41 @@ impl TypeWalk for GenericPredicate {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Canonical<T> {
    pub value: T,
-    pub kinds: Arc<[TyKind]>,
+    pub kinds: Arc<[TyVariableKind]>,
 }
 impl<T> Canonical<T> {
-    pub fn new(value: T, kinds: impl IntoIterator<Item = TyKind>) -> Self {
+    pub fn new(value: T, kinds: impl IntoIterator<Item = TyVariableKind>) -> Self {
        Self { value, kinds: kinds.into_iter().collect() }
    }
 }
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum TyKind {
-    General,
-    Integer,
-    Float,
-}
 /// A function signature as seen by type inference: Several parameter types and
 /// one return type.
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub struct FnSig {
+pub struct CallableSig {
    params_and_return: Arc<[Ty]>,
    is_varargs: bool,
 }
 /// A polymorphic function signature.
-pub type PolyFnSig = Binders<FnSig>;
+pub type PolyFnSig = Binders<CallableSig>;
-impl FnSig {
+impl CallableSig {
-    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty, is_varargs: bool) -> FnSig {
+    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty, is_varargs: bool) -> CallableSig {
        params.push(ret);
-        FnSig { params_and_return: params.into(), is_varargs }
+        CallableSig { params_and_return: params.into(), is_varargs }
    }
-    pub fn from_fn_ptr_substs(substs: &Substs, is_varargs: bool) -> FnSig {
+    pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig {
-        FnSig { params_and_return: Arc::clone(&substs.0), is_varargs }
+        CallableSig {
+            params_and_return: Arc::clone(&fn_ptr.substs.0),
+            is_varargs: fn_ptr.sig.variadic,
+        }
+    }
+    pub fn from_substs(substs: &Substs) -> CallableSig {
+        CallableSig { params_and_return: Arc::clone(&substs.0), is_varargs: false }
    }
    pub fn params(&self) -> &[Ty] {
@@ -702,7 +579,7 @@ impl FnSig {
    }
 }
-impl TypeWalk for FnSig {
+impl TypeWalk for CallableSig {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        for t in self.params_and_return.iter() {
            t.walk(f);
@@ -721,49 +598,42 @@ impl TypeWalk for FnSig {
 }
 impl Ty {
-    pub fn simple(ctor: TypeCtor) -> Ty {
-        Ty::Apply(ApplicationTy { ctor, parameters: Substs::empty() })
-    }
-    pub fn apply_one(ctor: TypeCtor, param: Ty) -> Ty {
-        Ty::Apply(ApplicationTy { ctor, parameters: Substs::single(param) })
-    }
-    pub fn apply(ctor: TypeCtor, parameters: Substs) -> Ty {
-        Ty::Apply(ApplicationTy { ctor, parameters })
-    }
    pub fn unit() -> Self {
-        Ty::apply(TypeCtor::Tuple { cardinality: 0 }, Substs::empty())
+        Ty::Tuple(0, Substs::empty())
    }
-    pub fn fn_ptr(sig: FnSig) -> Self {
-        Ty::apply(
+    pub fn fn_ptr(sig: CallableSig) -> Self {
-            TypeCtor::FnPtr { num_args: sig.params().len() as u16, is_varargs: sig.is_varargs },
+        Ty::Function(FnPointer {
-            Substs(sig.params_and_return),
+            num_args: sig.params().len(),
-        )
+            sig: FnSig { variadic: sig.is_varargs },
+            substs: Substs(sig.params_and_return),
+        })
    }
    pub fn builtin(builtin: BuiltinType) -> Self {
-        Ty::simple(match builtin {
+        match builtin {
-            BuiltinType::Char => TypeCtor::Char,
+            BuiltinType::Char => Ty::Scalar(Scalar::Char),
-            BuiltinType::Bool => TypeCtor::Bool,
+            BuiltinType::Bool => Ty::Scalar(Scalar::Bool),
-            BuiltinType::Str => TypeCtor::Str,
+            BuiltinType::Str => Ty::Str,
-            BuiltinType::Int(t) => TypeCtor::Int(IntTy::from(t).into()),
+            BuiltinType::Int(t) => Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))),
-            BuiltinType::Float(t) => TypeCtor::Float(FloatTy::from(t).into()),
+            BuiltinType::Uint(t) => Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))),
-        })
+            BuiltinType::Float(t) => Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))),
+        }
    }
    pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(mutability), parameters }) => {
+            Ty::Ref(mutability, parameters) => Some((parameters.as_single(), *mutability)),
-                Some((parameters.as_single(), *mutability))
-            }
            _ => None,
        }
    }
    pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> {
        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(mutability), parameters }) => {
+            Ty::Ref(mutability, parameters) => {
                Some((parameters.as_single(), Rawness::Ref, *mutability))
            }
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::RawPtr(mutability), parameters }) => {
+            Ty::Raw(mutability, parameters) => {
                Some((parameters.as_single(), Rawness::RawPtr, *mutability))
            }
            _ => None,
@@ -773,7 +643,7 @@ impl Ty {
    pub fn strip_references(&self) -> &Ty {
        let mut t: &Ty = self;
-        while let Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(_mutability), parameters }) = t {
+        while let Ty::Ref(_mutability, parameters) = t {
            t = parameters.as_single();
        }
@@ -782,30 +652,60 @@ impl Ty {
    pub fn as_adt(&self) -> Option<(AdtId, &Substs)> {
        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Adt(adt_def), parameters }) => {
+            Ty::Adt(adt_def, parameters) => Some((*adt_def, parameters)),
-                Some((*adt_def, parameters))
-            }
            _ => None,
        }
    }
    pub fn as_tuple(&self) -> Option<&Substs> {
        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Tuple { .. }, parameters }) => {
+            Ty::Tuple(_, substs) => Some(substs),
-                Some(parameters)
+            _ => None,
-            }
+        }
+    }
+    pub fn as_generic_def(&self) -> Option<GenericDefId> {
+        match *self {
+            Ty::Adt(adt, ..) => Some(adt.into()),
+            Ty::FnDef(callable, ..) => Some(callable.into()),
+            Ty::AssociatedType(type_alias, ..) => Some(type_alias.into()),
+            Ty::ForeignType(type_alias, ..) => Some(type_alias.into()),
            _ => None,
        }
    }
    pub fn is_never(&self) -> bool {
-        matches!(self, Ty::Apply(ApplicationTy { ctor: TypeCtor::Never, .. }))
+        matches!(self, Ty::Never)
    }
    pub fn is_unknown(&self) -> bool {
        matches!(self, Ty::Unknown)
    }
+    pub fn equals_ctor(&self, other: &Ty) -> bool {
+        match (self, other) {
+            (Ty::Adt(adt, ..), Ty::Adt(adt2, ..)) => adt == adt2,
+            (Ty::Slice(_), Ty::Slice(_)) | (Ty::Array(_), Ty::Array(_)) => true,
+            (Ty::FnDef(def_id, ..), Ty::FnDef(def_id2, ..)) => def_id == def_id2,
+            (Ty::OpaqueType(ty_id, ..), Ty::OpaqueType(ty_id2, ..)) => ty_id == ty_id2,
+            (Ty::AssociatedType(ty_id, ..), Ty::AssociatedType(ty_id2, ..))
+            | (Ty::ForeignType(ty_id, ..), Ty::ForeignType(ty_id2, ..)) => ty_id == ty_id2,
+            (Ty::Closure(def, expr, _), Ty::Closure(def2, expr2, _)) => {
+                expr == expr2 && def == def2
+            }
+            (Ty::Ref(mutability, ..), Ty::Ref(mutability2, ..))
+            | (Ty::Raw(mutability, ..), Ty::Raw(mutability2, ..)) => mutability == mutability2,
+            (
+                Ty::Function(FnPointer { num_args, sig, .. }),
+                Ty::Function(FnPointer { num_args: num_args2, sig: sig2, .. }),
+            ) => num_args == num_args2 && sig == sig2,
+            (Ty::Tuple(cardinality, _), Ty::Tuple(cardinality2, _)) => cardinality == cardinality2,
+            (Ty::Str, Ty::Str) | (Ty::Never, Ty::Never) => true,
+            (Ty::Scalar(scalar), Ty::Scalar(scalar2)) => scalar == scalar2,
+            _ => false,
+        }
+    }
    /// If this is a `dyn Trait` type, this returns the `Trait` part.
    pub fn dyn_trait_ref(&self) -> Option<&TraitRef> {
        match self {
@@ -824,41 +724,30 @@ impl Ty {
    fn builtin_deref(&self) -> Option<Ty> {
        match self {
-            Ty::Apply(a_ty) => match a_ty.ctor {
+            Ty::Ref(.., parameters) => Some(Ty::clone(parameters.as_single())),
-                TypeCtor::Ref(..) => Some(Ty::clone(a_ty.parameters.as_single())),
+            Ty::Raw(.., parameters) => Some(Ty::clone(parameters.as_single())),
-                TypeCtor::RawPtr(..) => Some(Ty::clone(a_ty.parameters.as_single())),
-                _ => None,
-            },
            _ => None,
        }
    }
    pub fn as_fn_def(&self) -> Option<FunctionId> {
        match self {
-            &Ty::Apply(ApplicationTy {
+            &Ty::FnDef(CallableDefId::FunctionId(func), ..) => Some(func),
-                ctor: TypeCtor::FnDef(CallableDefId::FunctionId(func)),
-                ..
-            }) => Some(func),
            _ => None,
        }
    }
-    pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<FnSig> {
+    pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> {
        match self {
-            Ty::Apply(a_ty) => match a_ty.ctor {
+            Ty::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
-                TypeCtor::FnPtr { is_varargs, .. } => {
+            Ty::FnDef(def, parameters) => {
-                    Some(FnSig::from_fn_ptr_substs(&a_ty.parameters, is_varargs))
+                let sig = db.callable_item_signature(*def);
-                }
+                Some(sig.subst(&parameters))
-                TypeCtor::FnDef(def) => {
+            }
-                    let sig = db.callable_item_signature(def);
+            Ty::Closure(.., substs) => {
-                    Some(sig.subst(&a_ty.parameters))
+                let sig_param = &substs[0];
-                }
+                sig_param.callable_sig(db)
-                TypeCtor::Closure { .. } => {
+            }
-                    let sig_param = &a_ty.parameters[0];
-                    sig_param.callable_sig(db)
-                }
-                _ => None,
-            },
            _ => None,
        }
    }
@@ -867,28 +756,66 @@ impl Ty {
    /// the `Substs` for these type parameters with the given ones. (So e.g. if
    /// `self` is `Option<_>` and the substs contain `u32`, we'll have
    /// `Option<u32>` afterwards.)
-    pub fn apply_substs(self, substs: Substs) -> Ty {
+    pub fn apply_substs(mut self, new_substs: Substs) -> Ty {
-        match self {
+        match &mut self {
-            Ty::Apply(ApplicationTy { ctor, parameters: previous_substs }) => {
+            Ty::Adt(_, substs)
-                assert_eq!(previous_substs.len(), substs.len());
+            | Ty::Slice(substs)
-                Ty::Apply(ApplicationTy { ctor, parameters: substs })
+            | Ty::Array(substs)
+            | Ty::Raw(_, substs)
+            | Ty::Ref(_, substs)
+            | Ty::FnDef(_, substs)
+            | Ty::Function(FnPointer { substs, .. })
+            | Ty::Tuple(_, substs)
+            | Ty::OpaqueType(_, substs)
+            | Ty::AssociatedType(_, substs)
+            | Ty::Closure(.., substs) => {
+                assert_eq!(substs.len(), new_substs.len());
+                *substs = new_substs;
            }
-            _ => self,
+            _ => (),
        }
+        self
    }
    /// 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<&Substs> {
        match self {
-            Ty::Apply(ApplicationTy { parameters, .. }) => Some(parameters.clone()),
+            Ty::Adt(_, substs)
+            | Ty::Slice(substs)
+            | Ty::Array(substs)
+            | Ty::Raw(_, substs)
+            | Ty::Ref(_, substs)
+            | Ty::FnDef(_, substs)
+            | Ty::Function(FnPointer { substs, .. })
+            | Ty::Tuple(_, substs)
+            | Ty::OpaqueType(_, substs)
+            | Ty::AssociatedType(_, substs)
+            | Ty::Closure(.., substs) => Some(substs),
+            _ => None,
+        }
+    }
+    pub fn substs_mut(&mut self) -> Option<&mut Substs> {
+        match self {
+            Ty::Adt(_, substs)
+            | Ty::Slice(substs)
+            | Ty::Array(substs)
+            | Ty::Raw(_, substs)
+            | Ty::Ref(_, substs)
+            | Ty::FnDef(_, substs)
+            | Ty::Function(FnPointer { substs, .. })
+            | Ty::Tuple(_, substs)
+            | Ty::OpaqueType(_, substs)
+            | Ty::AssociatedType(_, substs)
+            | Ty::Closure(.., substs) => Some(substs),
            _ => None,
        }
    }
    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::OpaqueType(opaque_ty_id), .. }) => {
+            Ty::OpaqueType(opaque_ty_id, ..) => {
                match opaque_ty_id {
                    OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => {
                        let krate = def.module(db.upcast()).krate();
@@ -911,7 +838,7 @@ impl Ty {
                    OpaqueTyId::ReturnTypeImplTrait(..) => None,
                }
            }
-            Ty::Opaque(opaque_ty) => {
+            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
                let predicates = match opaque_ty.opaque_ty_id {
                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
                        db.return_type_impl_traits(func).map(|it| {
@@ -949,13 +876,13 @@ impl Ty {
    pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::AssociatedType(type_alias_id), .. }) => {
+            Ty::AssociatedType(type_alias_id, ..) => {
                match type_alias_id.lookup(db.upcast()).container {
                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
                    _ => None,
                }
            }
-            Ty::Projection(projection_ty) => {
+            Ty::Alias(AliasTy::Projection(projection_ty)) => {
                match projection_ty.associated_ty.lookup(db.upcast()).container {
                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
                    _ => None,
@@ -1033,7 +960,7 @@ pub trait TypeWalk {
    {
        self.walk_mut_binders(
            &mut |ty, binders| {
-                if let &mut Ty::Bound(bound) = ty {
+                if let &mut Ty::BoundVar(bound) = ty {
                    if bound.debruijn >= binders {
                        *ty = substs.0[bound.index].clone().shift_bound_vars(binders);
                    }
@@ -1051,8 +978,8 @@ pub trait TypeWalk {
    {
        self.fold_binders(
            &mut |ty, binders| match ty {
-                Ty::Bound(bound) if bound.debruijn >= binders => {
+                Ty::BoundVar(bound) if bound.debruijn >= binders => {
-                    Ty::Bound(bound.shifted_in_from(n))
+                    Ty::BoundVar(bound.shifted_in_from(n))
                }
                ty => ty,
            },
@@ -1064,13 +991,13 @@ pub trait TypeWalk {
 impl TypeWalk for Ty {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        match self {
-            Ty::Apply(a_ty) => {
+            Ty::Alias(AliasTy::Projection(p_ty)) => {
-                for t in a_ty.parameters.iter() {
+                for t in p_ty.parameters.iter() {
                    t.walk(f);
                }
            }
-            Ty::Projection(p_ty) => {
+            Ty::Alias(AliasTy::Opaque(o_ty)) => {
-                for t in p_ty.parameters.iter() {
+                for t in o_ty.parameters.iter() {
                    t.walk(f);
                }
            }
@@ -1079,12 +1006,13 @@ impl TypeWalk for Ty {
                    p.walk(f);
                }
            }
-            Ty::Opaque(o_ty) => {
+            _ => {
-                for t in o_ty.parameters.iter() {
+                if let Some(substs) = self.substs() {
-                    t.walk(f);
+                    for t in substs.iter() {
+                        t.walk(f);
+                    }
                }
            }
-            Ty::Placeholder { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
        }
        f(self);
    }
@@ -1095,10 +1023,7 @@ impl TypeWalk for Ty {
        binders: DebruijnIndex,
    ) {
        match self {
-            Ty::Apply(a_ty) => {
+            Ty::Alias(AliasTy::Projection(p_ty)) => {
-                a_ty.parameters.walk_mut_binders(f, binders);
-            }
-            Ty::Projection(p_ty) => {
                p_ty.parameters.walk_mut_binders(f, binders);
            }
            Ty::Dyn(predicates) => {
@@ -1106,10 +1031,14 @@ impl TypeWalk for Ty {
                    p.walk_mut_binders(f, binders.shifted_in());
                }
            }
-            Ty::Opaque(o_ty) => {
+            Ty::Alias(AliasTy::Opaque(o_ty)) => {
                o_ty.parameters.walk_mut_binders(f, binders);
            }
-            Ty::Placeholder { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
+            _ => {
+                if let Some(substs) = self.substs_mut() {
+                    substs.walk_mut_binders(f, binders);
+                }
+            }
        }
        f(self, binders);
    }
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 99b0ecf3b..1b5843d48 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -8,6 +8,7 @@
 use std::{iter, sync::Arc};
 use base_db::CrateId;
+use chalk_ir::Mutability;
 use hir_def::{
    adt::StructKind,
    builtin_type::BuiltinType,
@@ -31,9 +32,9 @@ use crate::{
        all_super_trait_refs, associated_type_by_name_including_super_traits, generics,
        make_mut_slice, variant_data,
    },
-    Binders, BoundVar, DebruijnIndex, FnSig, GenericPredicate, OpaqueTy, OpaqueTyId, PolyFnSig,
+    AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
-    ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, ReturnTypeImplTraits, Substs,
+    OpaqueTy, OpaqueTyId, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
-    TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk,
+    ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 #[derive(Debug)]
@@ -145,13 +146,10 @@ impl Ty {
    pub fn from_hir_ext(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> (Self, Option<TypeNs>) {
        let mut res = None;
        let ty = match type_ref {
-            TypeRef::Never => Ty::simple(TypeCtor::Never),
+            TypeRef::Never => Ty::Never,
            TypeRef::Tuple(inner) => {
                let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| Ty::from_hir(ctx, tr)).collect();
-                Ty::apply(
+                Ty::Tuple(inner_tys.len(), Substs(inner_tys))
-                    TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
-                    Substs(inner_tys),
-                )
            }
            TypeRef::Path(path) => {
                let (ty, res_) = Ty::from_hir_path(ctx, path);
@@ -160,30 +158,31 @@ impl Ty {
            }
            TypeRef::RawPtr(inner, mutability) => {
                let inner_ty = Ty::from_hir(ctx, inner);
-                Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty)
+                Ty::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
            }
            TypeRef::Array(inner) => {
                let inner_ty = Ty::from_hir(ctx, inner);
-                Ty::apply_one(TypeCtor::Array, inner_ty)
+                Ty::Array(Substs::single(inner_ty))
            }
            TypeRef::Slice(inner) => {
                let inner_ty = Ty::from_hir(ctx, inner);
-                Ty::apply_one(TypeCtor::Slice, inner_ty)
+                Ty::Slice(Substs::single(inner_ty))
            }
            TypeRef::Reference(inner, _, mutability) => {
                let inner_ty = Ty::from_hir(ctx, inner);
-                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
+                Ty::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
            }
            TypeRef::Placeholder => Ty::Unknown,
            TypeRef::Fn(params, is_varargs) => {
-                let sig = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
+                let substs = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
-                Ty::apply(
+                Ty::Function(FnPointer {
-                    TypeCtor::FnPtr { num_args: sig.len() as u16 - 1, is_varargs: *is_varargs },
+                    num_args: substs.len() - 1,
-                    sig,
+                    sig: FnSig { variadic: *is_varargs },
-                )
+                    substs,
+                })
            }
            TypeRef::DynTrait(bounds) => {
-                let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
+                let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0));
                let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| {
                    bounds
                        .iter()
@@ -227,7 +226,10 @@ impl Ty {
                        let impl_trait_id = OpaqueTyId::ReturnTypeImplTrait(func, idx);
                        let generics = generics(ctx.db.upcast(), func.into());
                        let parameters = Substs::bound_vars(&generics, ctx.in_binders);
-                        Ty::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters })
+                        Ty::Alias(AliasTy::Opaque(OpaqueTy {
+                            opaque_ty_id: impl_trait_id,
+                            parameters,
+                        }))
                    }
                    ImplTraitLoweringMode::Param => {
                        let idx = ctx.impl_trait_counter.get();
@@ -258,7 +260,7 @@ impl Ty {
                            } else {
                                (0, 0, 0, 0)
                            };
-                        Ty::Bound(BoundVar::new(
+                        Ty::BoundVar(BoundVar::new(
                            ctx.in_binders,
                            idx as usize + parent_params + self_params + list_params,
                        ))
@@ -330,7 +332,7 @@ impl Ty {
            TypeNs::TraitId(trait_) => {
                // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there
                let self_ty = if remaining_segments.len() == 0 {
-                    Some(Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)))
+                    Some(Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)))
                } else {
                    None
                };
@@ -346,10 +348,10 @@ impl Ty {
                    match found {
                        Some((super_trait_ref, associated_ty)) => {
                            // FIXME handle type parameters on the segment
-                            Ty::Projection(ProjectionTy {
+                            Ty::Alias(AliasTy::Projection(ProjectionTy {
                                associated_ty,
                                parameters: super_trait_ref.substs,
-                            })
+                            }))
                        }
                        None => {
                            // FIXME: report error (associated type not found)
@@ -373,7 +375,7 @@ impl Ty {
                    TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id),
                    TypeParamLoweringMode::Variable => {
                        let idx = generics.param_idx(param_id).expect("matching generics");
-                        Ty::Bound(BoundVar::new(ctx.in_binders, idx))
+                        Ty::BoundVar(BoundVar::new(ctx.in_binders, idx))
                    }
                }
            }
@@ -414,7 +416,6 @@ impl Ty {
            // FIXME: report error
            TypeNs::EnumVariantId(_) => return (Ty::Unknown, None),
        };
        Ty::from_type_relative_path(ctx, ty, Some(resolution), remaining_segments)
    }
@@ -472,10 +473,10 @@ impl Ty {
                        // associated_type_shorthand_candidates does not do that
                        let substs = substs.shift_bound_vars(ctx.in_binders);
                        // FIXME handle type parameters on the segment
-                        return Some(Ty::Projection(ProjectionTy {
+                        return Some(Ty::Alias(AliasTy::Projection(ProjectionTy {
                            associated_ty,
                            parameters: substs,
-                        }));
+                        })));
                    }
                    None
@@ -676,7 +677,7 @@ impl GenericPredicate {
                            TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id),
                            TypeParamLoweringMode::Variable => {
                                let idx = generics.param_idx(param_id).expect("matching generics");
-                                Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, idx))
+                                Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx))
                            }
                        }
                    }
@@ -750,7 +751,7 @@ fn assoc_type_bindings_from_type_bound<'a>(
                preds.extend(GenericPredicate::from_type_bound(
                    ctx,
                    bound,
-                    Ty::Projection(projection_ty.clone()),
+                    Ty::Alias(AliasTy::Projection(projection_ty.clone())),
                ));
            }
            preds
@@ -760,7 +761,7 @@ fn assoc_type_bindings_from_type_bound<'a>(
 impl ReturnTypeImplTrait {
    fn from_hir(ctx: &TyLoweringContext, bounds: &[TypeBound]) -> Self {
        mark::hit!(lower_rpit);
-        let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
+        let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0));
        let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| {
            bounds
                .iter()
@@ -984,7 +985,7 @@ pub(crate) fn generic_defaults_query(
            // Each default can only refer to previous parameters.
            ty.walk_mut_binders(
                &mut |ty, binders| match ty {
-                    Ty::Bound(BoundVar { debruijn, index }) if *debruijn == binders => {
+                    Ty::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => {
                        if *index >= idx {
                            // type variable default referring to parameter coming
                            // after it. This is forbidden (FIXME: report
@@ -1017,7 +1018,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
    let ret = Ty::from_hir(&ctx_ret, &data.ret_type);
    let generics = generics(db.upcast(), def.into());
    let num_binders = generics.len();
-    Binders::new(num_binders, FnSig::from_params_and_return(params, ret, data.is_varargs))
+    Binders::new(num_binders, CallableSig::from_params_and_return(params, ret, data.is_varargs))
 }
 /// Build the declared type of a function. This should not need to look at the
@@ -1025,7 +1026,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
 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);
-    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
+    Binders::new(substs.len(), Ty::FnDef(def.into(), substs))
 }
 /// Build the declared type of a const.
@@ -1057,7 +1058,7 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS
    let params =
        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.into());
-    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value, false))
+    Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false))
 }
 /// Build the type of a tuple struct constructor.
@@ -1068,7 +1069,7 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T
    }
    let generics = generics(db.upcast(), def.into());
    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
+    Binders::new(substs.len(), Ty::FnDef(def.into(), substs))
 }
 fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {
@@ -1081,7 +1082,7 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId)
    let params =
        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.parent.into());
-    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value, false))
+    Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false))
 }
 /// Build the type of a tuple enum variant constructor.
@@ -1093,13 +1094,13 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
    }
    let generics = generics(db.upcast(), def.parent.into());
    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    Binders::new(substs.len(), Ty::apply(TypeCtor::FnDef(def.into()), substs))
+    Binders::new(substs.len(), Ty::FnDef(def.into(), substs))
 }
 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);
-    Binders::new(substs.len(), Ty::apply(TypeCtor::Adt(adt), substs))
+    Binders::new(substs.len(), Ty::Adt(adt, substs))
 }
 fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
@@ -1107,10 +1108,10 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
    let resolver = t.resolver(db.upcast());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
    if db.type_alias_data(t).is_extern {
-        Binders::new(substs.len(), Ty::apply(TypeCtor::ForeignType(t), substs))
+        Binders::new(0, Ty::ForeignType(t))
    } else {
+        let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
        let type_ref = &db.type_alias_data(t).type_ref;
        let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error));
        Binders::new(substs.len(), inner)
@@ -1259,3 +1260,10 @@ pub(crate) fn return_type_impl_traits(
        Some(Arc::new(Binders::new(num_binders, return_type_impl_traits)))
    }
 }
+pub(crate) fn lower_to_chalk_mutability(m: hir_def::type_ref::Mutability) -> Mutability {
+    match m {
+        hir_def::type_ref::Mutability::Shared => Mutability::Not,
+        hir_def::type_ref::Mutability::Mut => Mutability::Mut,
+    }
+}
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index b3d1fe9a4..f301a8477 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -6,12 +6,10 @@ use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use base_db::CrateId;
+use chalk_ir::Mutability;
 use hir_def::{
-    builtin_type::{IntBitness, Signedness},
+    lang_item::LangItemTarget, AdtId, AssocContainerId, AssocItemId, FunctionId, GenericDefId,
-    lang_item::LangItemTarget,
+    HasModule, ImplId, Lookup, ModuleId, TraitId, TypeAliasId,
-    type_ref::Mutability,
-    AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule, ImplId, Lookup, ModuleId,
-    TraitId,
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -19,17 +17,26 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
    autoderef,
    db::HirDatabase,
-    primitive::{FloatBitness, FloatTy, IntTy},
+    primitive::{self, FloatTy, IntTy, UintTy},
    utils::all_super_traits,
-    ApplicationTy, Canonical, DebruijnIndex, InEnvironment, Substs, TraitEnvironment, TraitRef, Ty,
+    Canonical, DebruijnIndex, FnPointer, FnSig, InEnvironment, Scalar, Substs, TraitEnvironment,
-    TyKind, TypeCtor, TypeWalk,
+    TraitRef, Ty, TypeWalk,
 };
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TyFingerprint {
-    Apply(TypeCtor),
+    Str,
+    Slice,
+    Array,
+    Never,
+    RawPtr(Mutability),
+    Scalar(Scalar),
+    Adt(AdtId),
    Dyn(TraitId),
+    Tuple(usize),
+    ForeignType(TypeAliasId),
+    FnPtr(usize, FnSig),
 }
 impl TyFingerprint {
@@ -37,68 +44,42 @@ impl TyFingerprint {
    /// have impls: if we have some `struct S`, we can have an `impl S`, but not
    /// `impl &S`. Hence, this will return `None` for reference types and such.
    pub(crate) fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
-        match ty {
+        let fp = match ty {
-            Ty::Apply(a_ty) => Some(TyFingerprint::Apply(a_ty.ctor)),
+            &Ty::Str => TyFingerprint::Str,
-            Ty::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_)),
+            &Ty::Never => TyFingerprint::Never,
-            _ => None,
+            &Ty::Slice(..) => TyFingerprint::Slice,
-        }
+            &Ty::Array(..) => TyFingerprint::Array,
+            &Ty::Scalar(scalar) => TyFingerprint::Scalar(scalar),
+            &Ty::Adt(adt, _) => TyFingerprint::Adt(adt),
+            &Ty::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality),
+            &Ty::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability),
+            &Ty::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id),
+            &Ty::Function(FnPointer { num_args, sig, .. }) => TyFingerprint::FnPtr(num_args, sig),
+            Ty::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
+            _ => return None,
+        };
+        Some(fp)
    }
 }
 pub(crate) const ALL_INT_FPS: [TyFingerprint; 12] = [
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
+    TyFingerprint::Scalar(Scalar::Int(IntTy::I8)),
-        signedness: Signedness::Unsigned,
+    TyFingerprint::Scalar(Scalar::Int(IntTy::I16)),
-        bitness: IntBitness::X8,
+    TyFingerprint::Scalar(Scalar::Int(IntTy::I32)),
-    })),
+    TyFingerprint::Scalar(Scalar::Int(IntTy::I64)),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
+    TyFingerprint::Scalar(Scalar::Int(IntTy::I128)),
-        signedness: Signedness::Unsigned,
+    TyFingerprint::Scalar(Scalar::Int(IntTy::Isize)),
-        bitness: IntBitness::X16,
+    TyFingerprint::Scalar(Scalar::Uint(UintTy::U8)),
-    })),
+    TyFingerprint::Scalar(Scalar::Uint(UintTy::U16)),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
+    TyFingerprint::Scalar(Scalar::Uint(UintTy::U32)),
-        signedness: Signedness::Unsigned,
+    TyFingerprint::Scalar(Scalar::Uint(UintTy::U64)),
-        bitness: IntBitness::X32,
+    TyFingerprint::Scalar(Scalar::Uint(UintTy::U128)),
-    })),
+    TyFingerprint::Scalar(Scalar::Uint(UintTy::Usize)),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Unsigned,
-        bitness: IntBitness::X64,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Unsigned,
-        bitness: IntBitness::X128,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Unsigned,
-        bitness: IntBitness::Xsize,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Signed,
-        bitness: IntBitness::X8,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Signed,
-        bitness: IntBitness::X16,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Signed,
-        bitness: IntBitness::X32,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Signed,
-        bitness: IntBitness::X64,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Signed,
-        bitness: IntBitness::X128,
-    })),
-    TyFingerprint::Apply(TypeCtor::Int(IntTy {
-        signedness: Signedness::Signed,
-        bitness: IntBitness::Xsize,
-    })),
 ];
 pub(crate) const ALL_FLOAT_FPS: [TyFingerprint; 2] = [
-    TyFingerprint::Apply(TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 })),
+    TyFingerprint::Scalar(Scalar::Float(FloatTy::F32)),
-    TyFingerprint::Apply(TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 })),
+    TyFingerprint::Scalar(Scalar::Float(FloatTy::F64)),
 ];
 /// Trait impls defined or available in some crate.
@@ -250,27 +231,29 @@ impl Ty {
        let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
        let lang_item_targets = match self {
-            Ty::Apply(a_ty) => match a_ty.ctor {
+            Ty::Adt(def_id, _) => {
-                TypeCtor::Adt(def_id) => {
+                return mod_to_crate_ids(def_id.module(db.upcast()));
-                    return mod_to_crate_ids(def_id.module(db.upcast()));
+            }
-                }
+            Ty::ForeignType(type_alias_id) => {
-                TypeCtor::ForeignType(type_alias_id) => {
+                return mod_to_crate_ids(type_alias_id.lookup(db.upcast()).module(db.upcast()));
-                    return mod_to_crate_ids(type_alias_id.lookup(db.upcast()).module(db.upcast()));
+            }
-                }
+            Ty::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
-                TypeCtor::Bool => lang_item_crate!("bool"),
+            Ty::Scalar(Scalar::Char) => lang_item_crate!("char"),
-                TypeCtor::Char => lang_item_crate!("char"),
+            Ty::Scalar(Scalar::Float(f)) => match f {
-                TypeCtor::Float(f) => match f.bitness {
+                // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
-                    // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
+                FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"),
-                    FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"),
+                FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"),
-                    FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"),
-                },
-                TypeCtor::Int(i) => lang_item_crate!(i.ty_to_string()),
-                TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
-                TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
-                TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
-                TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!("mut_ptr"),
-                _ => return None,
            },
+            &Ty::Scalar(Scalar::Int(t)) => {
+                lang_item_crate!(primitive::int_ty_to_string(t))
+            }
+            &Ty::Scalar(Scalar::Uint(t)) => {
+                lang_item_crate!(primitive::uint_ty_to_string(t))
+            }
+            Ty::Str => lang_item_crate!("str_alloc", "str"),
+            Ty::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
+            Ty::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
+            Ty::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
            Ty::Dyn(_) => {
                return self.dyn_trait().and_then(|trait_| {
                    mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))
@@ -447,7 +430,7 @@ fn iterate_method_candidates_with_autoref(
    }
    let refed = Canonical {
        kinds: deref_chain[0].kinds.clone(),
-        value: Ty::apply_one(TypeCtor::Ref(Mutability::Shared), deref_chain[0].value.clone()),
+        value: Ty::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone())),
    };
    if iterate_method_candidates_by_receiver(
        &refed,
@@ -463,7 +446,7 @@ fn iterate_method_candidates_with_autoref(
    }
    let ref_muted = Canonical {
        kinds: deref_chain[0].kinds.clone(),
-        value: Ty::apply_one(TypeCtor::Ref(Mutability::Mut), deref_chain[0].value.clone()),
+        value: Ty::Ref(Mutability::Mut, Substs::single(deref_chain[0].value.clone())),
    };
    if iterate_method_candidates_by_receiver(
        &ref_muted,
@@ -685,7 +668,7 @@ pub(crate) fn inherent_impl_substs(
        .build();
    let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
    let mut kinds = self_ty.kinds.to_vec();
-    kinds.extend(iter::repeat(TyKind::General).take(vars.len()));
+    kinds.extend(iter::repeat(chalk_ir::TyVariableKind::General).take(vars.len()));
    let tys = Canonical { kinds: kinds.into(), value: (self_ty_with_vars, self_ty.value.clone()) };
    let substs = super::infer::unify(&tys);
    // We only want the substs for the vars we added, not the ones from self_ty.
@@ -701,7 +684,7 @@ pub(crate) fn inherent_impl_substs(
 fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
    s.fold_binders(
        &mut |ty, binders| {
-            if let Ty::Bound(bound) = &ty {
+            if let Ty::BoundVar(bound) = &ty {
                if bound.index >= num_vars_to_keep && bound.debruijn >= binders {
                    Ty::Unknown
                } else {
@@ -777,7 +760,7 @@ fn generic_implements_goal(
        .push(self_ty.value)
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
        .build();
-    kinds.extend(iter::repeat(TyKind::General).take(substs.len() - 1));
+    kinds.extend(iter::repeat(chalk_ir::TyVariableKind::General).take(substs.len() - 1));
    let trait_ref = TraitRef { trait_, substs };
    let obligation = super::Obligation::Trait(trait_ref);
    Canonical { kinds: kinds.into(), value: InEnvironment::new(env, obligation) }
@@ -790,11 +773,9 @@ fn autoderef_method_receiver(
 ) -> Vec<Canonical<Ty>> {
    let mut deref_chain: Vec<_> = autoderef::autoderef(db, Some(krate), ty).collect();
    // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
-    if let Some(Ty::Apply(ApplicationTy { ctor: TypeCtor::Array, parameters })) =
+    if let Some(Ty::Array(parameters)) = deref_chain.last().map(|ty| &ty.value) {
-        deref_chain.last().map(|ty| &ty.value)
-    {
        let kinds = deref_chain.last().unwrap().kinds.clone();
-        let unsized_ty = Ty::apply(TypeCtor::Slice, parameters.clone());
+        let unsized_ty = Ty::Slice(parameters.clone());
        deref_chain.push(Canonical { value: unsized_ty, kinds })
    }
    deref_chain
diff --git a/crates/hir_ty/src/op.rs b/crates/hir_ty/src/op.rs
index 0870874fc..bb9b8bbfc 100644
--- a/crates/hir_ty/src/op.rs
+++ b/crates/hir_ty/src/op.rs
@@ -1,27 +1,27 @@
 //! Helper functions for binary operator type inference.
+use chalk_ir::TyVariableKind;
 use hir_def::expr::{ArithOp, BinaryOp, CmpOp};
-use super::{InferTy, Ty, TypeCtor};
+use crate::{Scalar, Ty};
-use crate::ApplicationTy;
 pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
    match op {
-        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => Ty::simple(TypeCtor::Bool),
+        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => Ty::Scalar(Scalar::Bool),
        BinaryOp::Assignment { .. } => Ty::unit(),
        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => match lhs_ty {
-            Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
+            Ty::Scalar(Scalar::Int(_))
-                TypeCtor::Int(..) | TypeCtor::Float(..) => lhs_ty,
+            | Ty::Scalar(Scalar::Uint(_))
-                _ => Ty::Unknown,
+            | Ty::Scalar(Scalar::Float(_)) => lhs_ty,
-            },
+            Ty::InferenceVar(_, TyVariableKind::Integer)
-            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
+            | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
            _ => Ty::Unknown,
        },
        BinaryOp::ArithOp(_) => match rhs_ty {
-            Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
+            Ty::Scalar(Scalar::Int(_))
-                TypeCtor::Int(..) | TypeCtor::Float(..) => rhs_ty,
+            | Ty::Scalar(Scalar::Uint(_))
-                _ => Ty::Unknown,
+            | Ty::Scalar(Scalar::Float(_)) => rhs_ty,
-            },
+            Ty::InferenceVar(_, TyVariableKind::Integer)
-            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => rhs_ty,
+            | Ty::InferenceVar(_, TyVariableKind::Float) => rhs_ty,
            _ => Ty::Unknown,
        },
    }
@@ -29,29 +29,23 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
 pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
    match op {
-        BinaryOp::LogicOp(..) => Ty::simple(TypeCtor::Bool),
+        BinaryOp::LogicOp(..) => Ty::Scalar(Scalar::Bool),
        BinaryOp::Assignment { op: None } => lhs_ty,
        BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty {
-            Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
+            Ty::Scalar(_) | Ty::Str => lhs_ty,
-                TypeCtor::Int(..)
+            Ty::InferenceVar(_, TyVariableKind::Integer)
-                | TypeCtor::Float(..)
+            | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
-                | TypeCtor::Str
-                | TypeCtor::Char
-                | TypeCtor::Bool => lhs_ty,
-                _ => Ty::Unknown,
-            },
-            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
            _ => Ty::Unknown,
        },
        BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => Ty::Unknown,
        BinaryOp::CmpOp(CmpOp::Ord { .. })
        | BinaryOp::Assignment { op: Some(_) }
        | BinaryOp::ArithOp(_) => match lhs_ty {
-            Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
+            Ty::Scalar(Scalar::Int(_))
-                TypeCtor::Int(..) | TypeCtor::Float(..) => lhs_ty,
+            | Ty::Scalar(Scalar::Uint(_))
-                _ => Ty::Unknown,
+            | Ty::Scalar(Scalar::Float(_)) => lhs_ty,
-            },
+            Ty::InferenceVar(_, TyVariableKind::Integer)
-            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
+            | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty,
            _ => Ty::Unknown,
        },
    }
diff --git a/crates/hir_ty/src/primitive.rs b/crates/hir_ty/src/primitive.rs
index 37966b709..2449addfb 100644
--- a/crates/hir_ty/src/primitive.rs
+++ b/crates/hir_ty/src/primitive.rs
@@ -3,137 +3,63 @@
 //! * during type inference, they can be uncertain (ie, `let x = 92;`)
 //! * they don't belong to any particular crate.
-use std::fmt;
+pub use chalk_ir::{FloatTy, IntTy, UintTy};
+pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint};
-pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, FloatBitness, IntBitness, Signedness};
+pub fn int_ty_to_string(ty: IntTy) -> &'static str {
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+    match ty {
-pub struct IntTy {
+        IntTy::Isize => "isize",
-    pub signedness: Signedness,
+        IntTy::I8 => "i8",
-    pub bitness: IntBitness,
+        IntTy::I16 => "i16",
-}
+        IntTy::I32 => "i32",
+        IntTy::I64 => "i64",
-impl fmt::Debug for IntTy {
+        IntTy::I128 => "i128",
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-impl fmt::Display for IntTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
-impl IntTy {
-    pub fn isize() -> IntTy {
-        IntTy { signedness: Signedness::Signed, bitness: IntBitness::Xsize }
-    }
-    pub fn i8() -> IntTy {
-        IntTy { signedness: Signedness::Signed, bitness: IntBitness::X8 }
-    }
-    pub fn i16() -> IntTy {
-        IntTy { signedness: Signedness::Signed, bitness: IntBitness::X16 }
-    }
-    pub fn i32() -> IntTy {
-        IntTy { signedness: Signedness::Signed, bitness: IntBitness::X32 }
-    }
-    pub fn i64() -> IntTy {
-        IntTy { signedness: Signedness::Signed, bitness: IntBitness::X64 }
-    }
-    pub fn i128() -> IntTy {
-        IntTy { signedness: Signedness::Signed, bitness: IntBitness::X128 }
    }
-    pub fn usize() -> IntTy {
-        IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize }
-    }
-    pub fn u8() -> IntTy {
-        IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X8 }
-    }
-    pub fn u16() -> IntTy {
-        IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X16 }
-    }
-    pub fn u32() -> IntTy {
-        IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X32 }
-    }
-    pub fn u64() -> IntTy {
-        IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X64 }
-    }
-    pub fn u128() -> IntTy {
-        IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X128 }
-    }
-    pub fn ty_to_string(self) -> &'static str {
-        match (self.signedness, self.bitness) {
-            (Signedness::Signed, IntBitness::Xsize) => "isize",
-            (Signedness::Signed, IntBitness::X8) => "i8",
-            (Signedness::Signed, IntBitness::X16) => "i16",
-            (Signedness::Signed, IntBitness::X32) => "i32",
-            (Signedness::Signed, IntBitness::X64) => "i64",
-            (Signedness::Signed, IntBitness::X128) => "i128",
-            (Signedness::Unsigned, IntBitness::Xsize) => "usize",
-            (Signedness::Unsigned, IntBitness::X8) => "u8",
-            (Signedness::Unsigned, IntBitness::X16) => "u16",
-            (Signedness::Unsigned, IntBitness::X32) => "u32",
-            (Signedness::Unsigned, IntBitness::X64) => "u64",
-            (Signedness::Unsigned, IntBitness::X128) => "u128",
-        }
-    }
-}
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct FloatTy {
-    pub bitness: FloatBitness,
 }
-impl fmt::Debug for FloatTy {
+pub fn uint_ty_to_string(ty: UintTy) -> &'static str {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    match ty {
-        fmt::Display::fmt(self, f)
+        UintTy::Usize => "usize",
+        UintTy::U8 => "u8",
+        UintTy::U16 => "u16",
+        UintTy::U32 => "u32",
+        UintTy::U64 => "u64",
+        UintTy::U128 => "u128",
    }
 }
-impl fmt::Display for FloatTy {
+pub fn float_ty_to_string(ty: FloatTy) -> &'static str {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    match ty {
-        write!(f, "{}", self.ty_to_string())
+        FloatTy::F32 => "f32",
+        FloatTy::F64 => "f64",
    }
 }
-impl FloatTy {
+pub(super) fn int_ty_from_builtin(t: BuiltinInt) -> IntTy {
-    pub fn f32() -> FloatTy {
+    match t {
-        FloatTy { bitness: FloatBitness::X32 }
+        BuiltinInt::Isize => IntTy::Isize,
-    }
+        BuiltinInt::I8 => IntTy::I8,
+        BuiltinInt::I16 => IntTy::I16,
-    pub fn f64() -> FloatTy {
+        BuiltinInt::I32 => IntTy::I32,
-        FloatTy { bitness: FloatBitness::X64 }
+        BuiltinInt::I64 => IntTy::I64,
-    }
+        BuiltinInt::I128 => IntTy::I128,
-    pub fn ty_to_string(self) -> &'static str {
-        match self.bitness {
-            FloatBitness::X32 => "f32",
-            FloatBitness::X64 => "f64",
-        }
    }
 }
-impl From<BuiltinInt> for IntTy {
+pub(super) fn uint_ty_from_builtin(t: BuiltinUint) -> UintTy {
-    fn from(t: BuiltinInt) -> Self {
+    match t {
-        IntTy { signedness: t.signedness, bitness: t.bitness }
+        BuiltinUint::Usize => UintTy::Usize,
+        BuiltinUint::U8 => UintTy::U8,
+        BuiltinUint::U16 => UintTy::U16,
+        BuiltinUint::U32 => UintTy::U32,
+        BuiltinUint::U64 => UintTy::U64,
+        BuiltinUint::U128 => UintTy::U128,
    }
 }
-impl From<BuiltinFloat> for FloatTy {
+pub(super) fn float_ty_from_builtin(t: BuiltinFloat) -> FloatTy {
-    fn from(t: BuiltinFloat) -> Self {
+    match t {
-        FloatTy { bitness: t.bitness }
+        BuiltinFloat::F32 => FloatTy::F32,
+        BuiltinFloat::F64 => FloatTy::F64,
    }
 }
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 12ec4657b..2947857a5 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -2491,3 +2491,58 @@ fn inner_use_enum_rename() {
        "#]],
    )
 }
+#[test]
+fn box_into_vec() {
+    check_infer(
+        r#"
+#[lang = "sized"]
+pub trait Sized {}
+#[lang = "unsize"]
+pub trait Unsize<T: ?Sized> {}
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T> {}
+pub unsafe trait Allocator {}
+pub struct Global;
+unsafe impl Allocator for Global {}
+#[lang = "owned_box"]
+#[fundamental]
+pub struct Box<T: ?Sized, A: Allocator = Global>;
+impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A> {}
+pub struct Vec<T, A: Allocator = Global> {}
+#[lang = "slice"]
+impl<T> [T] {}
+#[lang = "slice_alloc"]
+impl<T> [T] {
+    pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
+        unimplemented!()
+    }
+}
+fn test() {
+    let vec = <[_]>::into_vec(box [1i32]);
+}
+"#,
+        expect![[r#"
+            569..573 'self': Box<[T], A>
+            602..634 '{     ...     }': Vec<T, A>
+            612..628 'unimpl...ted!()': Vec<T, A>
+            648..694 '{     ...2]); }': ()
+            658..661 'vec': Vec<i32, Global>
+            664..679 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global>
+            664..691 '<[_]>:...1i32])': Vec<i32, Global>
+            680..690 'box [1i32]': Box<[i32; _], Global>
+            684..690 '[1i32]': [i32; _]
+            685..689 '1i32': i32
+        "#]],
+    )
+}
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index dfa51896b..e4cdb6d53 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -129,7 +129,7 @@ pub(crate) fn trait_solve_query(
    log::info!("trait_solve_query({})", goal.value.value.display(db));
    if let Obligation::Projection(pred) = &goal.value.value {
-        if let Ty::Bound(_) = &pred.projection_ty.parameters[0] {
+        if let Ty::BoundVar(_) = &pred.projection_ty.parameters[0] {
            // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
            return Some(Solution::Ambig(Guidance::Unknown));
        }
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index d74c83737..e513fa8f4 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -19,8 +19,8 @@ use crate::{
    display::HirDisplay,
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
    utils::generics,
-    BoundVar, CallableDefId, DebruijnIndex, FnSig, GenericPredicate, ProjectionPredicate,
+    BoundVar, CallableDefId, CallableSig, DebruijnIndex, GenericPredicate, ProjectionPredicate,
-    ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    ProjectionTy, Substs, TraitRef, Ty,
 };
 use mapping::{
    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsAssocType,
@@ -90,7 +90,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            ty: &Ty,
            binders: &CanonicalVarKinds<Interner>,
        ) -> Option<chalk_ir::TyVariableKind> {
-            if let Ty::Bound(bv) = ty {
+            if let Ty::BoundVar(bv) = ty {
                let binders = binders.as_slice(&Interner);
                if bv.debruijn == DebruijnIndex::INNERMOST {
                    if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind {
@@ -220,18 +220,18 @@ 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(Ty::Bound(BoundVar {
+                        substs: Substs::single(Ty::BoundVar(BoundVar {
                            debruijn: DebruijnIndex::INNERMOST,
                            index: 0,
                        })),
                    });
                    let proj_bound = GenericPredicate::Projection(ProjectionPredicate {
                        // The parameter of the opaque type.
-                        ty: Ty::Bound(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }),
+                        ty: Ty::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }),
                        projection_ty: ProjectionTy {
                            associated_ty: future_output,
                            // Self type as the first parameter.
-                            parameters: Substs::single(Ty::Bound(BoundVar::new(
+                            parameters: Substs::single(Ty::BoundVar(BoundVar::new(
                                DebruijnIndex::INNERMOST,
                                0,
                            ))),
@@ -286,9 +286,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
        let sig_ty: Ty =
            from_chalk(self.db, substs.at(&Interner, 0).assert_ty_ref(&Interner).clone());
-        let sig = FnSig::from_fn_ptr_substs(
+        let sig = CallableSig::from_substs(
            &sig_ty.substs().expect("first closure param should be fn ptr"),
-            false,
        );
        let io = rust_ir::FnDefInputsAndOutputDatum {
            argument_types: sig.params().iter().map(|ty| ty.clone().to_chalk(self.db)).collect(),
@@ -393,7 +392,7 @@ pub(crate) fn associated_ty_data_query(
    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);
-    let self_ty = Ty::Bound(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0));
+    let self_ty = Ty::BoundVar(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0));
    let bounds = type_alias_data
        .bounds
        .iter()
@@ -489,10 +488,11 @@ pub(crate) fn struct_datum_query(
    struct_id: AdtId,
 ) -> Arc<StructDatum> {
    debug!("struct_datum {:?}", struct_id);
-    let type_ctor = TypeCtor::Adt(from_chalk(db, struct_id));
+    let adt_id = from_chalk(db, struct_id);
+    let type_ctor = Ty::Adt(adt_id, Substs::empty());
    debug!("struct {:?} = {:?}", struct_id, type_ctor);
-    let num_params = type_ctor.num_ty_params(db);
+    let num_params = generics(db.upcast(), adt_id.into()).len();
-    let upstream = type_ctor.krate(db) != Some(krate);
+    let upstream = adt_id.module(db.upcast()).krate() != krate;
    let where_clauses = type_ctor
        .as_generic_def()
        .map(|generic_def| {
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 8700d664e..db1760e6c 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -4,20 +4,20 @@
 //! conversions.
 use chalk_ir::{
-    cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex, Scalar,
+    cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex,
    UniverseIndex,
 };
 use chalk_solve::rust_ir;
 use base_db::salsa::InternKey;
-use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, TypeAliasId};
+use hir_def::{AssocContainerId, GenericDefId, Lookup, TypeAliasId};
 use crate::{
    db::HirDatabase,
-    primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness},
+    primitive::UintTy,
    traits::{Canonical, Obligation},
-    ApplicationTy, CallableDefId, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
+    AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy,
-    ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeCtor,
+    OpaqueTyId, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty,
 };
 use super::interner::*;
@@ -27,88 +27,68 @@ impl ToChalk for Ty {
    type Chalk = chalk_ir::Ty<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
        match self {
-            Ty::Apply(apply_ty) => match apply_ty.ctor {
+            Ty::Ref(m, parameters) => ref_to_chalk(db, m, parameters),
-                TypeCtor::Ref(m) => ref_to_chalk(db, m, apply_ty.parameters),
+            Ty::Array(parameters) => array_to_chalk(db, parameters),
-                TypeCtor::Array => array_to_chalk(db, apply_ty.parameters),
+            Ty::Function(FnPointer { sig: FnSig { variadic }, substs, .. }) => {
-                TypeCtor::FnPtr { num_args: _, is_varargs } => {
+                let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner));
-                    let substitution =
+                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
-                        chalk_ir::FnSubst(apply_ty.parameters.to_chalk(db).shifted_in(&Interner));
+                    num_binders: 0,
-                    chalk_ir::TyKind::Function(chalk_ir::FnPointer {
+                    sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic },
-                        num_binders: 0,
+                    substitution,
-                        sig: chalk_ir::FnSig {
+                })
-                            abi: (),
+                .intern(&Interner)
-                            safety: chalk_ir::Safety::Safe,
+            }
-                            variadic: is_varargs,
+            Ty::AssociatedType(type_alias, substs) => {
-                        },
+                let assoc_type = TypeAliasAsAssocType(type_alias);
-                        substitution,
+                let assoc_type_id = assoc_type.to_chalk(db);
-                    })
+                let substitution = substs.to_chalk(db);
-                    .intern(&Interner)
+                chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
-                }
+            }
-                TypeCtor::AssociatedType(type_alias) => {
-                    let assoc_type = TypeAliasAsAssocType(type_alias);
-                    let assoc_type_id = assoc_type.to_chalk(db);
-                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
-                }
-                TypeCtor::OpaqueType(impl_trait_id) => {
+            Ty::OpaqueType(impl_trait_id, substs) => {
-                    let id = impl_trait_id.to_chalk(db);
+                let id = impl_trait_id.to_chalk(db);
-                    let substitution = apply_ty.parameters.to_chalk(db);
+                let substitution = substs.to_chalk(db);
-                    chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
+                chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
-                }
+            }
-                TypeCtor::ForeignType(type_alias) => {
+            Ty::ForeignType(type_alias) => {
-                    let foreign_type = TypeAliasAsForeignType(type_alias);
+                let foreign_type = TypeAliasAsForeignType(type_alias);
-                    let foreign_type_id = foreign_type.to_chalk(db);
+                let foreign_type_id = foreign_type.to_chalk(db);
-                    chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
+                chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
-                }
+            }
-                TypeCtor::Bool => chalk_ir::TyKind::Scalar(Scalar::Bool).intern(&Interner),
+            Ty::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
-                TypeCtor::Char => chalk_ir::TyKind::Scalar(Scalar::Char).intern(&Interner),
-                TypeCtor::Int(int_ty) => {
-                    chalk_ir::TyKind::Scalar(int_ty_to_chalk(int_ty)).intern(&Interner)
-                }
-                TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }) => {
-                    chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F32))
-                        .intern(&Interner)
-                }
-                TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }) => {
-                    chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64))
-                        .intern(&Interner)
-                }
-                TypeCtor::Tuple { cardinality } => {
+            Ty::Tuple(cardinality, substs) => {
-                    let substitution = apply_ty.parameters.to_chalk(db);
+                let substitution = substs.to_chalk(db);
-                    chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
+                chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
-                }
+            }
-                TypeCtor::RawPtr(mutability) => {
+            Ty::Raw(mutability, substs) => {
-                    let ty = apply_ty.parameters[0].clone().to_chalk(db);
+                let ty = substs[0].clone().to_chalk(db);
-                    chalk_ir::TyKind::Raw(mutability.to_chalk(db), ty).intern(&Interner)
+                chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner)
-                }
+            }
-                TypeCtor::Slice => {
+            Ty::Slice(substs) => {
-                    chalk_ir::TyKind::Slice(apply_ty.parameters[0].clone().to_chalk(db))
+                chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner)
-                        .intern(&Interner)
+            }
-                }
+            Ty::Str => chalk_ir::TyKind::Str.intern(&Interner),
-                TypeCtor::Str => chalk_ir::TyKind::Str.intern(&Interner),
+            Ty::FnDef(callable_def, substs) => {
-                TypeCtor::FnDef(callable_def) => {
+                let id = callable_def.to_chalk(db);
-                    let id = callable_def.to_chalk(db);
+                let substitution = substs.to_chalk(db);
-                    let substitution = apply_ty.parameters.to_chalk(db);
+                chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
-                    chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
+            }
-                }
+            Ty::Never => chalk_ir::TyKind::Never.intern(&Interner),
-                TypeCtor::Never => chalk_ir::TyKind::Never.intern(&Interner),
-                TypeCtor::Closure { def, expr } => {
+            Ty::Closure(def, expr, substs) => {
-                    let closure_id = db.intern_closure((def, expr));
+                let closure_id = db.intern_closure((def, expr));
-                    let substitution = apply_ty.parameters.to_chalk(db);
+                let substitution = substs.to_chalk(db);
-                    chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner)
+                chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner)
-                }
+            }
-                TypeCtor::Adt(adt_id) => {
+            Ty::Adt(adt_id, substs) => {
-                    let substitution = apply_ty.parameters.to_chalk(db);
+                let substitution = substs.to_chalk(db);
-                    chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
+                chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
-                }
+            }
-            },
+            Ty::Alias(AliasTy::Projection(proj_ty)) => {
-            Ty::Projection(proj_ty) => {
                let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db);
                let substitution = proj_ty.parameters.to_chalk(db);
                chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
@@ -126,8 +106,8 @@ impl ToChalk for Ty {
                }
                .to_ty::<Interner>(&Interner)
            }
-            Ty::Bound(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
+            Ty::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
-            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
+            Ty::InferenceVar(..) => panic!("uncanonicalized infer ty"),
            Ty::Dyn(predicates) => {
                let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
                    &Interner,
@@ -139,7 +119,7 @@ impl ToChalk for Ty {
                };
                chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
            }
-            Ty::Opaque(opaque_ty) => {
+            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
                let opaque_ty_id = opaque_ty.opaque_ty_id.to_chalk(db);
                let substitution = opaque_ty.parameters.to_chalk(db);
                chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
@@ -154,9 +134,7 @@ impl ToChalk for Ty {
    fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
        match chalk.data(&Interner).kind.clone() {
            chalk_ir::TyKind::Error => Ty::Unknown,
-            chalk_ir::TyKind::Array(ty, _size) => {
+            chalk_ir::TyKind::Array(ty, _size) => Ty::Array(Substs::single(from_chalk(db, ty))),
-                Ty::apply(TypeCtor::Array, Substs::single(from_chalk(db, ty)))
-            }
            chalk_ir::TyKind::Placeholder(idx) => {
                assert_eq!(idx.ui, UniverseIndex::ROOT);
                let interned_id = crate::db::GlobalTypeParamId::from_intern_id(
@@ -168,12 +146,12 @@ impl ToChalk for Ty {
                let associated_ty =
                    from_chalk::<TypeAliasAsAssocType, _>(db, proj.associated_ty_id).0;
                let parameters = from_chalk(db, proj.substitution);
-                Ty::Projection(ProjectionTy { associated_ty, parameters })
+                Ty::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters }))
            }
            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
                let impl_trait_id = from_chalk(db, opaque_ty.opaque_ty_id);
                let parameters = from_chalk(db, opaque_ty.substitution);
-                Ty::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters })
+                Ty::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters }))
            }
            chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                num_binders,
@@ -182,19 +160,17 @@ impl ToChalk for Ty {
                ..
            }) => {
                assert_eq!(num_binders, 0);
-                let parameters: Substs = from_chalk(
+                let substs: Substs = from_chalk(
                    db,
                    substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
                );
-                Ty::Apply(ApplicationTy {
+                Ty::Function(FnPointer {
-                    ctor: TypeCtor::FnPtr {
+                    num_args: (substs.len() - 1),
-                        num_args: (parameters.len() - 1) as u16,
+                    sig: FnSig { variadic },
-                        is_varargs: variadic,
+                    substs,
-                    },
-                    parameters,
                })
            }
-            chalk_ir::TyKind::BoundVar(idx) => Ty::Bound(idx),
+            chalk_ir::TyKind::BoundVar(idx) => Ty::BoundVar(idx),
            chalk_ir::TyKind::InferenceVar(_iv, _kind) => Ty::Unknown,
            chalk_ir::TyKind::Dyn(where_clauses) => {
                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
@@ -207,93 +183,66 @@ impl ToChalk for Ty {
                Ty::Dyn(predicates)
            }
-            chalk_ir::TyKind::Adt(struct_id, subst) => {
+            chalk_ir::TyKind::Adt(struct_id, subst) => Ty::Adt(struct_id.0, from_chalk(db, subst)),
-                apply_ty_from_chalk(db, TypeCtor::Adt(struct_id.0), subst)
+            chalk_ir::TyKind::AssociatedType(type_id, subst) => Ty::AssociatedType(
-            }
+                from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0,
-            chalk_ir::TyKind::AssociatedType(type_id, subst) => apply_ty_from_chalk(
+                from_chalk(db, subst),
-                db,
-                TypeCtor::AssociatedType(from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0),
-                subst,
            ),
            chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => {
-                apply_ty_from_chalk(db, TypeCtor::OpaqueType(from_chalk(db, opaque_type_id)), subst)
+                Ty::OpaqueType(from_chalk(db, opaque_type_id), from_chalk(db, subst))
            }
-            chalk_ir::TyKind::Scalar(Scalar::Bool) => Ty::simple(TypeCtor::Bool),
+            chalk_ir::TyKind::Scalar(scalar) => Ty::Scalar(scalar),
-            chalk_ir::TyKind::Scalar(Scalar::Char) => Ty::simple(TypeCtor::Char),
-            chalk_ir::TyKind::Scalar(Scalar::Int(int_ty)) => Ty::simple(TypeCtor::Int(IntTy {
-                signedness: Signedness::Signed,
-                bitness: bitness_from_chalk_int(int_ty),
-            })),
-            chalk_ir::TyKind::Scalar(Scalar::Uint(uint_ty)) => Ty::simple(TypeCtor::Int(IntTy {
-                signedness: Signedness::Unsigned,
-                bitness: bitness_from_chalk_uint(uint_ty),
-            })),
-            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) => {
-                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }))
-            }
-            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => {
-                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }))
-            }
            chalk_ir::TyKind::Tuple(cardinality, subst) => {
-                apply_ty_from_chalk(db, TypeCtor::Tuple { cardinality: cardinality as u16 }, subst)
+                Ty::Tuple(cardinality, from_chalk(db, subst))
            }
            chalk_ir::TyKind::Raw(mutability, ty) => {
-                Ty::apply_one(TypeCtor::RawPtr(from_chalk(db, mutability)), from_chalk(db, ty))
+                Ty::Raw(mutability, Substs::single(from_chalk(db, ty)))
            }
-            chalk_ir::TyKind::Slice(ty) => Ty::apply_one(TypeCtor::Slice, from_chalk(db, ty)),
+            chalk_ir::TyKind::Slice(ty) => Ty::Slice(Substs::single(from_chalk(db, ty))),
            chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                Ty::apply_one(TypeCtor::Ref(from_chalk(db, mutability)), from_chalk(db, ty))
+                Ty::Ref(mutability, Substs::single(from_chalk(db, ty)))
            }
-            chalk_ir::TyKind::Str => Ty::simple(TypeCtor::Str),
+            chalk_ir::TyKind::Str => Ty::Str,
-            chalk_ir::TyKind::Never => Ty::simple(TypeCtor::Never),
+            chalk_ir::TyKind::Never => Ty::Never,
            chalk_ir::TyKind::FnDef(fn_def_id, subst) => {
-                let callable_def = from_chalk(db, fn_def_id);
+                Ty::FnDef(from_chalk(db, fn_def_id), from_chalk(db, subst))
-                apply_ty_from_chalk(db, TypeCtor::FnDef(callable_def), subst)
            }
            chalk_ir::TyKind::Closure(id, subst) => {
                let id: crate::db::ClosureId = id.into();
                let (def, expr) = db.lookup_intern_closure(id);
-                apply_ty_from_chalk(db, TypeCtor::Closure { def, expr }, subst)
+                Ty::Closure(def, expr, from_chalk(db, subst))
            }
-            chalk_ir::TyKind::Foreign(foreign_def_id) => Ty::simple(TypeCtor::ForeignType(
+            chalk_ir::TyKind::Foreign(foreign_def_id) => {
-                from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0,
+                Ty::ForeignType(from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0)
-            )),
+            }
            chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME
            chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME
        }
    }
 }
-fn apply_ty_from_chalk(
-    db: &dyn HirDatabase,
-    ctor: TypeCtor,
-    subst: chalk_ir::Substitution<Interner>,
-) -> Ty {
-    Ty::Apply(ApplicationTy { ctor, parameters: from_chalk(db, subst) })
-}
 /// We currently don't model lifetimes, but Chalk does. So, we have to insert a
 /// fake lifetime here, because Chalks built-in logic may expect it to be there.
 fn ref_to_chalk(
    db: &dyn HirDatabase,
-    mutability: Mutability,
+    mutability: chalk_ir::Mutability,
    subst: Substs,
 ) -> chalk_ir::Ty<Interner> {
    let arg = subst[0].clone().to_chalk(db);
    let lifetime = LifetimeData::Static.intern(&Interner);
-    chalk_ir::TyKind::Ref(mutability.to_chalk(db), lifetime, arg).intern(&Interner)
+    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
 }
 /// We currently don't model constants, but Chalk does. So, we have to insert a
 /// fake constant here, because Chalks built-in logic may expect it to be there.
 fn array_to_chalk(db: &dyn HirDatabase, subst: Substs) -> chalk_ir::Ty<Interner> {
    let arg = subst[0].clone().to_chalk(db);
-    let usize_ty =
+    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
-        chalk_ir::TyKind::Scalar(Scalar::Uint(chalk_ir::UintTy::Usize)).intern(&Interner);
    let const_ = chalk_ir::ConstData {
        ty: usize_ty,
        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
@@ -364,71 +313,6 @@ impl ToChalk for OpaqueTyId {
    }
 }
-fn bitness_from_chalk_uint(uint_ty: chalk_ir::UintTy) -> IntBitness {
-    use chalk_ir::UintTy;
-    match uint_ty {
-        UintTy::Usize => IntBitness::Xsize,
-        UintTy::U8 => IntBitness::X8,
-        UintTy::U16 => IntBitness::X16,
-        UintTy::U32 => IntBitness::X32,
-        UintTy::U64 => IntBitness::X64,
-        UintTy::U128 => IntBitness::X128,
-    }
-}
-fn bitness_from_chalk_int(int_ty: chalk_ir::IntTy) -> IntBitness {
-    use chalk_ir::IntTy;
-    match int_ty {
-        IntTy::Isize => IntBitness::Xsize,
-        IntTy::I8 => IntBitness::X8,
-        IntTy::I16 => IntBitness::X16,
-        IntTy::I32 => IntBitness::X32,
-        IntTy::I64 => IntBitness::X64,
-        IntTy::I128 => IntBitness::X128,
-    }
-}
-fn int_ty_to_chalk(int_ty: IntTy) -> Scalar {
-    use chalk_ir::{IntTy, UintTy};
-    match int_ty.signedness {
-        Signedness::Signed => Scalar::Int(match int_ty.bitness {
-            IntBitness::Xsize => IntTy::Isize,
-            IntBitness::X8 => IntTy::I8,
-            IntBitness::X16 => IntTy::I16,
-            IntBitness::X32 => IntTy::I32,
-            IntBitness::X64 => IntTy::I64,
-            IntBitness::X128 => IntTy::I128,
-        }),
-        Signedness::Unsigned => Scalar::Uint(match int_ty.bitness {
-            IntBitness::Xsize => UintTy::Usize,
-            IntBitness::X8 => UintTy::U8,
-            IntBitness::X16 => UintTy::U16,
-            IntBitness::X32 => UintTy::U32,
-            IntBitness::X64 => UintTy::U64,
-            IntBitness::X128 => UintTy::U128,
-        }),
-    }
-}
-impl ToChalk for Mutability {
-    type Chalk = chalk_ir::Mutability;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
-        match self {
-            Mutability::Shared => chalk_ir::Mutability::Not,
-            Mutability::Mut => chalk_ir::Mutability::Mut,
-        }
-    }
-    fn from_chalk(_db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        match chalk {
-            chalk_ir::Mutability::Mut => Mutability::Mut,
-            chalk_ir::Mutability::Not => Mutability::Shared,
-        }
-    }
-}
 impl ToChalk for hir_def::ImplId {
    type Chalk = ImplId;
@@ -632,20 +516,12 @@ where
    type Chalk = chalk_ir::Canonical<T::Chalk>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Canonical<T::Chalk> {
-        let kinds = self
+        let kinds = self.kinds.iter().map(|&tk| {
-            .kinds
+            chalk_ir::CanonicalVarKind::new(
-            .iter()
+                chalk_ir::VariableKind::Ty(tk),
-            .map(|k| match k {
+                chalk_ir::UniverseIndex::ROOT,
-                TyKind::General => chalk_ir::TyVariableKind::General,
+            )
-                TyKind::Integer => chalk_ir::TyVariableKind::Integer,
+        });
-                TyKind::Float => chalk_ir::TyVariableKind::Float,
-            })
-            .map(|tk| {
-                chalk_ir::CanonicalVarKind::new(
-                    chalk_ir::VariableKind::Ty(tk),
-                    chalk_ir::UniverseIndex::ROOT,
-                )
-            });
        let value = self.value.to_chalk(db);
        chalk_ir::Canonical {
            value,
@@ -658,17 +534,13 @@ where
            .binders
            .iter(&Interner)
            .map(|k| match k.kind {
-                chalk_ir::VariableKind::Ty(tk) => match tk {
+                chalk_ir::VariableKind::Ty(tk) => tk,
-                    chalk_ir::TyVariableKind::General => TyKind::General,
-                    chalk_ir::TyVariableKind::Integer => TyKind::Integer,
-                    chalk_ir::TyVariableKind::Float => TyKind::Float,
-                },
                // HACK: Chalk can sometimes return new lifetime variables. We
                // want to just skip them, but to not mess up the indices of
                // other variables, we'll just create a new type variable in
                // their place instead. This should not matter (we never see the
                // actual *uses* of the lifetime variable).
-                chalk_ir::VariableKind::Lifetime => TyKind::General,
+                chalk_ir::VariableKind::Lifetime => chalk_ir::TyVariableKind::General,
                chalk_ir::VariableKind::Const(_) => panic!("unexpected const from Chalk"),
            })
            .collect();
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 9a605b09d..20b799490 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -3496,4 +3496,33 @@ mod foo$0;
            "#]],
        );
    }
+    #[test]
+    fn hover_self_in_use() {
+        check(
+            r#"
+//! This should not appear
+mod foo {
+    /// But this should appear
+    pub mod bar {}
+}
+use foo::bar::{self$0};
+"#,
+            expect![[r#"
+                *self*
+                ```rust
+                test::foo
+                ```
+                ```rust
+                pub mod bar
+                ```
+                ---
+                But this should appear
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 5d0449e56..fef70533d 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -39,6 +39,15 @@ pub struct Declaration {
    pub access: Option<ReferenceAccess>,
 }
+// Feature: Find All References
+//
+// Shows all references of the item at the cursor location
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[Shift+Alt+F12]
+// |===
 pub(crate) fn find_all_refs(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 175ddd759..22ddeeae3 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -59,6 +59,15 @@ pub(crate) fn prepare_rename(
    Ok(RangeInfo::new(range, ()))
 }
+// Feature: Rename
+//
+// Renames the item below the cursor and all of its references
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[F2]
+// |===
 pub(crate) fn rename(
    db: &RootDatabase,
    position: FilePosition,
diff --git a/crates/ide_assists/src/handlers/convert_comment_block.rs b/crates/ide_assists/src/handlers/convert_comment_block.rs
new file mode 100644
index 000000000..cdc45fc42
--- /dev/null
+++ b/crates/ide_assists/src/handlers/convert_comment_block.rs
@@ -0,0 +1,419 @@
+use itertools::Itertools;
+use std::convert::identity;
+use syntax::{
+    ast::{
+        self,
+        edit::IndentLevel,
+        Comment, CommentKind,
+        CommentPlacement::{Inner, Outer},
+        CommentShape::{self, Block, Line},
+        Whitespace,
+    },
+    AstToken, Direction, SyntaxElement, TextRange,
+};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+/// Assist: line_to_block
+///
+/// Converts comments between block and single-line form
+///
+/// ```
+///    // Multi-line
+///    // comment
+/// ```
+/// ->
+/// ```
+///   /**
+///   Multi-line
+///   comment
+///   */
+/// ```
+pub(crate) fn convert_comment_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    if let Some(comment) = ctx.find_token_at_offset::<ast::Comment>() {
+        // Only allow comments which are alone on their line
+        if let Some(prev) = comment.syntax().prev_token() {
+            if Whitespace::cast(prev).filter(|w| w.text().contains('\n')).is_none() {
+                return None;
+            }
+        }
+        return match comment.kind().shape {
+            ast::CommentShape::Block => block_to_line(acc, comment),
+            ast::CommentShape::Line => line_to_block(acc, comment),
+        };
+    }
+    return None;
+}
+fn block_to_line(acc: &mut Assists, comment: ast::Comment) -> Option<()> {
+    let target = comment.syntax().text_range();
+    acc.add(
+        AssistId("block_to_line", AssistKind::RefactorRewrite),
+        "Replace block comment with line comments",
+        target,
+        |edit| {
+            let indentation = IndentLevel::from_token(comment.syntax());
+            let line_prefix =
+                comment_kind_prefix(CommentKind { shape: CommentShape::Line, ..comment.kind() });
+            let text = comment.text();
+            let text = &text[comment.prefix().len()..(text.len() - "*/".len())].trim();
+            let lines = text.lines().peekable();
+            let indent_spaces = indentation.to_string();
+            let output = lines
+                .map(|l| l.trim_start_matches(&indent_spaces))
+                .map(|l| {
+                    // Don't introduce trailing whitespace
+                    if l.is_empty() {
+                        line_prefix.to_string()
+                    } else {
+                        format!("{} {}", line_prefix, l.trim_start_matches(&indent_spaces))
+                    }
+                })
+                .join(&format!("\n{}", indent_spaces));
+            edit.replace(target, output)
+        },
+    )
+}
+fn line_to_block(acc: &mut Assists, comment: ast::Comment) -> Option<()> {
+    // Find all the comments we'll be collapsing into a block
+    let comments = relevant_line_comments(&comment);
+    // Establish the target of our edit based on the comments we found
+    let target = TextRange::new(
+        comments[0].syntax().text_range().start(),
+        comments.last().unwrap().syntax().text_range().end(),
+    );
+    acc.add(
+        AssistId("line_to_block", AssistKind::RefactorRewrite),
+        "Replace line comments with a single block comment",
+        target,
+        |edit| {
+            // We pick a single indentation level for the whole block comment based on the
+            // comment where the assist was invoked. This will be prepended to the
+            // contents of each line comment when they're put into the block comment.
+            let indentation = IndentLevel::from_token(&comment.syntax());
+            let block_comment_body =
+                comments.into_iter().map(|c| line_comment_text(indentation, c)).join("\n");
+            let block_prefix =
+                comment_kind_prefix(CommentKind { shape: CommentShape::Block, ..comment.kind() });
+            let output =
+                format!("{}\n{}\n{}*/", block_prefix, block_comment_body, indentation.to_string());
+            edit.replace(target, output)
+        },
+    )
+}
+/// The line -> block assist can  be invoked from anywhere within a sequence of line comments.
+/// relevant_line_comments crawls backwards and forwards finding the complete sequence of comments that will
+/// be joined.
+fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
+    // The prefix identifies the kind of comment we're dealing with
+    let prefix = comment.prefix();
+    let same_prefix = |c: &ast::Comment| c.prefix() == prefix;
+    // These tokens are allowed to exist between comments
+    let skippable = |not: &SyntaxElement| {
+        not.clone()
+            .into_token()
+            .and_then(Whitespace::cast)
+            .map(|w| !w.spans_multiple_lines())
+            .unwrap_or(false)
+    };
+    // Find all preceding comments (in reverse order) that have the same prefix
+    let prev_comments = comment
+        .syntax()
+        .siblings_with_tokens(Direction::Prev)
+        .filter(|s| !skippable(s))
+        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
+        .take_while(|opt_com| opt_com.is_some())
+        .filter_map(identity)
+        .skip(1); // skip the first element so we don't duplicate it in next_comments
+    let next_comments = comment
+        .syntax()
+        .siblings_with_tokens(Direction::Next)
+        .filter(|s| !skippable(s))
+        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
+        .take_while(|opt_com| opt_com.is_some())
+        .filter_map(identity);
+    let mut comments: Vec<_> = prev_comments.collect();
+    comments.reverse();
+    comments.extend(next_comments);
+    comments
+}
+// Line comments usually begin with a single space character following the prefix as seen here:
+//^
+// But comments can also include indented text:
+//    > Hello there
+//
+// We handle this by stripping *AT MOST* one space character from the start of the line
+// This has its own problems because it can cause alignment issues:
+//
+//              /*
+// a      ----> a
+//b       ----> b
+//              */
+//
+// But since such comments aren't idiomatic we're okay with this.
+fn line_comment_text(indentation: IndentLevel, comm: ast::Comment) -> String {
+    let contents_without_prefix = comm.text().strip_prefix(comm.prefix()).unwrap();
+    let contents = contents_without_prefix.strip_prefix(' ').unwrap_or(contents_without_prefix);
+    // Don't add the indentation if the line is empty
+    if contents.is_empty() {
+        contents.to_owned()
+    } else {
+        indentation.to_string() + &contents
+    }
+}
+fn comment_kind_prefix(ck: ast::CommentKind) -> &'static str {
+    match (ck.shape, ck.doc) {
+        (Line, Some(Inner)) => "//!",
+        (Line, Some(Outer)) => "///",
+        (Line, None) => "//",
+        (Block, Some(Inner)) => "/*!",
+        (Block, Some(Outer)) => "/**",
+        (Block, None) => "/*",
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn single_line_to_block() {
+        check_assist(
+            convert_comment_block,
+            r#"
+// line$0 comment
+fn main() {
+    foo();
+}
+"#,
+            r#"
+/*
+line comment
+*/
+fn main() {
+    foo();
+}
+"#,
+        );
+    }
+    #[test]
+    fn single_line_to_block_indented() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // line$0 comment
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /*
+    line comment
+    */
+    foo();
+}
+"#,
+        );
+    }
+    #[test]
+    fn multiline_to_block() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // above
+    // line$0 comment
+    //
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /*
+    above
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+    #[test]
+    fn end_of_line_to_block() {
+        check_assist_not_applicable(
+            convert_comment_block,
+            r#"
+fn main() {
+    foo(); // end-of-line$0 comment
+}
+"#,
+        );
+    }
+    #[test]
+    fn single_line_different_kinds() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    /// different prefix
+    // line$0 comment
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    /// different prefix
+    /*
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+    #[test]
+    fn single_line_separate_chunks() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    // different chunk
+    // line$0 comment
+    // below
+    foo();
+}
+"#,
+            r#"
+fn main() {
+    // different chunk
+    /*
+    line comment
+    below
+    */
+    foo();
+}
+"#,
+        );
+    }
+    #[test]
+    fn doc_block_comment_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/**
+ hi$0 there
+*/
+"#,
+            r#"
+/// hi there
+"#,
+        );
+    }
+    #[test]
+    fn block_comment_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/*
+ hi$0 there
+*/
+"#,
+            r#"
+// hi there
+"#,
+        );
+    }
+    #[test]
+    fn inner_doc_block_to_lines() {
+        check_assist(
+            convert_comment_block,
+            r#"
+/*!
+ hi$0 there
+*/
+"#,
+            r#"
+//! hi there
+"#,
+        );
+    }
+    #[test]
+    fn block_to_lines_indent() {
+        check_assist(
+            convert_comment_block,
+            r#"
+fn main() {
+    /*!
+    hi$0 there
+    ```
+      code_sample
+    ```
+    */
+}
+"#,
+            r#"
+fn main() {
+    //! hi there
+    //!
+    //! ```
+    //!   code_sample
+    //! ```
+}
+"#,
+        );
+    }
+    #[test]
+    fn end_of_line_block_to_line() {
+        check_assist_not_applicable(
+            convert_comment_block,
+            r#"
+fn main() {
+    foo(); /* end-of-line$0 comment */
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/handlers/convert_for_to_iter_for_each.rs b/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs
index 9fddf889c..27da28bc0 100644
--- a/crates/ide_assists/src/handlers/convert_for_to_iter_for_each.rs
+++ b/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs
@@ -3,17 +3,18 @@ use hir::known;
 use ide_db::helpers::FamousDefs;
 use stdx::format_to;
 use syntax::{ast, AstNode};
+use test_utils::mark;
 use crate::{AssistContext, AssistId, AssistKind, Assists};
-// Assist: convert_for_to_iter_for_each
+// Assist: replace_for_loop_with_for_each
 //
 // Converts a for loop into a for_each loop on the Iterator.
 //
 // ```
 // fn main() {
 //     let x = vec![1, 2, 3];
-//     for $0v in x {
+//     for$0 v in x {
 //         let y = v * 2;
 //     }
 // }
@@ -27,15 +28,19 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 //     });
 // }
 // ```
-pub(crate) fn convert_for_to_iter_for_each(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+pub(crate) fn replace_for_loop_with_for_each(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let for_loop = ctx.find_node_at_offset::<ast::ForExpr>()?;
    let iterable = for_loop.iterable()?;
    let pat = for_loop.pat()?;
    let body = for_loop.loop_body()?;
+    if body.syntax().text_range().start() < ctx.offset() {
+        mark::hit!(not_available_in_body);
+        return None;
+    }
    acc.add(
-        AssistId("convert_for_to_iter_for_each", AssistKind::RefactorRewrite),
+        AssistId("replace_for_loop_with_for_each", AssistKind::RefactorRewrite),
-        "Convert a for loop into an Iterator::for_each",
+        "Replace this for loop with `Iterator::for_each`",
        for_loop.syntax().text_range(),
        |builder| {
            let mut buf = String::new();
@@ -145,13 +150,13 @@ pub struct NoIterMethod;
            FamousDefs::FIXTURE,
            EMPTY_ITER_FIXTURE
        );
-        check_assist(convert_for_to_iter_for_each, before, after);
+        check_assist(replace_for_loop_with_for_each, before, after);
    }
    #[test]
    fn test_not_for() {
        check_assist_not_applicable(
-            convert_for_to_iter_for_each,
+            replace_for_loop_with_for_each,
            r"
 let mut x = vec![1, 2, 3];
 x.iter_mut().$0for_each(|v| *v *= 2);
@@ -162,7 +167,7 @@ x.iter_mut().$0for_each(|v| *v *= 2);
    #[test]
    fn test_simple_for() {
        check_assist(
-            convert_for_to_iter_for_each,
+            replace_for_loop_with_for_each,
            r"
 fn main() {
    let x = vec![1, 2, 3];
@@ -181,6 +186,21 @@ fn main() {
    }
    #[test]
+    fn not_available_in_body() {
+        mark::check!(not_available_in_body);
+        check_assist_not_applicable(
+            replace_for_loop_with_for_each,
+            r"
+fn main() {
+    let x = vec![1, 2, 3];
+    for v in x {
+        $0v *= 2;
+    }
+}",
+        )
+    }
+    #[test]
    fn test_for_borrowed() {
        check_assist_with_fixtures(
            r"
@@ -255,7 +275,7 @@ fn main() {
    #[test]
    fn test_for_borrowed_mut_behind_var() {
        check_assist(
-            convert_for_to_iter_for_each,
+            replace_for_loop_with_for_each,
            r"
 fn main() {
    let x = vec![1, 2, 3];
diff --git a/crates/ide_assists/src/handlers/replace_let_with_if_let.rs b/crates/ide_assists/src/handlers/replace_let_with_if_let.rs
index 5a27ada6b..be7e724b5 100644
--- a/crates/ide_assists/src/handlers/replace_let_with_if_let.rs
+++ b/crates/ide_assists/src/handlers/replace_let_with_if_let.rs
@@ -1,5 +1,6 @@
 use std::iter::once;
+use ide_db::ty_filter::TryEnum;
 use syntax::{
    ast::{
        self,
@@ -10,7 +11,6 @@ use syntax::{
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
-use ide_db::ty_filter::TryEnum;
 // Assist: replace_let_with_if_let
 //
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 4c067d451..9c8148462 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -114,8 +114,8 @@ mod handlers {
    mod apply_demorgan;
    mod auto_import;
    mod change_visibility;
-    mod convert_for_to_iter_for_each;
    mod convert_integer_literal;
+    mod convert_comment_block;
    mod early_return;
    mod expand_glob_import;
    mod extract_function;
@@ -132,8 +132,8 @@ mod handlers {
    mod generate_enum_projection_method;
    mod generate_from_impl_for_enum;
    mod generate_function;
-    mod generate_getter;
    mod generate_getter_mut;
+    mod generate_getter;
    mod generate_impl;
    mod generate_new;
    mod generate_setter;
@@ -156,6 +156,7 @@ mod handlers {
    mod reorder_fields;
    mod reorder_impl;
    mod replace_derive_with_manual_impl;
+    mod replace_for_loop_with_for_each;
    mod replace_if_let_with_match;
    mod replace_impl_trait_with_generic;
    mod replace_let_with_if_let;
@@ -177,11 +178,10 @@ mod handlers {
            apply_demorgan::apply_demorgan,
            auto_import::auto_import,
            change_visibility::change_visibility,
-            convert_for_to_iter_for_each::convert_for_to_iter_for_each,
            convert_integer_literal::convert_integer_literal,
+            convert_comment_block::convert_comment_block,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
-            move_module_to_file::move_module_to_file,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
            fill_match_arms::fill_match_arms,
            fix_visibility::fix_visibility,
@@ -191,12 +191,12 @@ mod handlers {
            generate_default_from_enum_variant::generate_default_from_enum_variant,
            generate_derive::generate_derive,
            generate_enum_is_method::generate_enum_is_method,
-            generate_enum_projection_method::generate_enum_try_into_method,
            generate_enum_projection_method::generate_enum_as_method,
+            generate_enum_projection_method::generate_enum_try_into_method,
            generate_from_impl_for_enum::generate_from_impl_for_enum,
            generate_function::generate_function,
-            generate_getter::generate_getter,
            generate_getter_mut::generate_getter_mut,
+            generate_getter::generate_getter,
            generate_impl::generate_impl,
            generate_new::generate_new,
            generate_setter::generate_setter,
@@ -210,6 +210,7 @@ mod handlers {
            move_bounds::move_bounds_to_where_clause,
            move_guard::move_arm_cond_to_match_guard,
            move_guard::move_guard_to_arm_body,
+            move_module_to_file::move_module_to_file,
            pull_assignment_up::pull_assignment_up,
            qualify_path::qualify_path,
            raw_string::add_hash,
@@ -221,6 +222,7 @@ mod handlers {
            reorder_fields::reorder_fields,
            reorder_impl::reorder_impl,
            replace_derive_with_manual_impl::replace_derive_with_manual_impl,
+            replace_for_loop_with_for_each::replace_for_loop_with_for_each,
            replace_if_let_with_match::replace_if_let_with_match,
            replace_if_let_with_match::replace_match_with_if_let,
            replace_impl_trait_with_generic::replace_impl_trait_with_generic,
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index 384eb7eee..b7f616760 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -190,8 +190,8 @@ fn assist_order_field_struct() {
    let mut assists = assists.iter();
    assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
-    assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
+    assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a setter method");
    assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
 }
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 7f6dbbccf..4f007aa48 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -193,29 +193,6 @@ pub(crate) fn frobnicate() {}
 }
 #[test]
-fn doctest_convert_for_to_iter_for_each() {
-    check_doc_test(
-        "convert_for_to_iter_for_each",
-        r#####"
-fn main() {
-    let x = vec![1, 2, 3];
-    for $0v in x {
-        let y = v * 2;
-    }
-}
-"#####,
-        r#####"
-fn main() {
-    let x = vec![1, 2, 3];
-    x.into_iter().for_each(|v| {
-        let y = v * 2;
-    });
-}
-"#####,
-    )
-}
-#[test]
 fn doctest_convert_integer_literal() {
    check_doc_test(
        "convert_integer_literal",
@@ -1180,6 +1157,29 @@ impl Debug for S {
 }
 #[test]
+fn doctest_replace_for_loop_with_for_each() {
+    check_doc_test(
+        "replace_for_loop_with_for_each",
+        r#####"
+fn main() {
+    let x = vec![1, 2, 3];
+    for$0 v in x {
+        let y = v * 2;
+    }
+}
+"#####,
+        r#####"
+fn main() {
+    let x = vec![1, 2, 3];
+    x.into_iter().for_each(|v| {
+        let y = v * 2;
+    });
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_replace_if_let_with_match() {
    check_doc_test(
        "replace_if_let_with_match",
diff --git a/crates/mbe/Cargo.toml b/crates/mbe/Cargo.toml
index 46f11ad38..bb2656a80 100644
--- a/crates/mbe/Cargo.toml
+++ b/crates/mbe/Cargo.toml
@@ -21,5 +21,4 @@ test_utils = { path = "../test_utils", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
 [dev-dependencies]
-profile = { path = "../profile", version = "0.0.0" }
+profile = { path = "../profile" }
diff --git a/crates/mbe/src/benchmark.rs b/crates/mbe/src/benchmark.rs
index 13db5eef1..503ad1355 100644
--- a/crates/mbe/src/benchmark.rs
+++ b/crates/mbe/src/benchmark.rs
@@ -191,7 +191,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, MacroRules>) -> Vec<(String, tt
            let c = 1013904223;
            *seed = usize::wrapping_add(usize::wrapping_mul(*seed, a), c);
            return *seed;
-        };
+        }
        fn make_ident(ident: &str) -> tt::TokenTree {
            tt::Leaf::Ident(tt::Ident { id: tt::TokenId::unspecified(), text: SmolStr::new(ident) })
                .into()
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 6c8c28980..4c1b3036a 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -20,7 +20,7 @@ proc_macro_api = { path = "../proc_macro_api", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
-cargo_metadata = "0.12.2"
+cargo_metadata = "0.13"
 # used as proc macro test targets
 serde_derive = "1.0.106"
diff --git a/crates/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index a8504f762..952b4a97f 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -14,7 +14,6 @@ use std::collections::HashMap;
 use std::hash::Hash;
 use std::iter::FromIterator;
 use std::ops::Bound;
-use std::str::FromStr;
 use std::{ascii, vec::IntoIter};
 type Group = tt::Subtree;
@@ -278,6 +277,42 @@ impl server::FreeFunctions for Rustc {
    }
 }
+fn subtree_replace_token_ids_with_unspecified(subtree: tt::Subtree) -> tt::Subtree {
+    tt::Subtree {
+        delimiter: subtree.delimiter.map(|d| tt::Delimiter { id: tt::TokenId::unspecified(), ..d }),
+        token_trees: subtree
+            .token_trees
+            .into_iter()
+            .map(|t| token_tree_replace_token_ids_with_unspecified(t))
+            .collect(),
+    }
+}
+fn token_tree_replace_token_ids_with_unspecified(tt: tt::TokenTree) -> tt::TokenTree {
+    match tt {
+        tt::TokenTree::Leaf(leaf) => {
+            tt::TokenTree::Leaf(leaf_replace_token_ids_with_unspecified(leaf))
+        }
+        tt::TokenTree::Subtree(subtree) => {
+            tt::TokenTree::Subtree(subtree_replace_token_ids_with_unspecified(subtree))
+        }
+    }
+}
+fn leaf_replace_token_ids_with_unspecified(leaf: tt::Leaf) -> tt::Leaf {
+    match leaf {
+        tt::Leaf::Literal(lit) => {
+            tt::Leaf::Literal(tt::Literal { id: tt::TokenId::unspecified(), ..lit })
+        }
+        tt::Leaf::Punct(punct) => {
+            tt::Leaf::Punct(tt::Punct { id: tt::TokenId::unspecified(), ..punct })
+        }
+        tt::Leaf::Ident(ident) => {
+            tt::Leaf::Ident(tt::Ident { id: tt::TokenId::unspecified(), ..ident })
+        }
+    }
+}
 impl server::TokenStream for Rustc {
    fn new(&mut self) -> Self::TokenStream {
        Self::TokenStream::new()
@@ -287,7 +322,8 @@ impl server::TokenStream for Rustc {
        stream.is_empty()
    }
    fn from_str(&mut self, src: &str) -> Self::TokenStream {
-        Self::TokenStream::from_str(src).expect("cannot parse string")
+        let (subtree, _) = mbe::parse_to_token_tree(src).expect("cannot parse string");
+        TokenStream::with_subtree(subtree_replace_token_ids_with_unspecified(subtree))
    }
    fn to_string(&mut self, stream: &Self::TokenStream) -> String {
        stream.to_string()
diff --git a/crates/proc_macro_srv/src/tests/utils.rs b/crates/proc_macro_srv/src/tests/utils.rs
index 196abb8fc..22813052d 100644
--- a/crates/proc_macro_srv/src/tests/utils.rs
+++ b/crates/proc_macro_srv/src/tests/utils.rs
@@ -8,6 +8,7 @@ use test_utils::assert_eq_text;
 mod fixtures {
    use cargo_metadata::Message;
+    use std::path::PathBuf;
    use std::process::Command;
    // Use current project metadata to get the proc-macro dylib path
@@ -24,7 +25,7 @@ mod fixtures {
                    if artifact.target.kind.contains(&"proc-macro".to_string()) {
                        let repr = format!("{} {}", crate_name, version);
                        if artifact.package_id.repr.starts_with(&repr) {
-                            return artifact.filenames[0].clone();
+                            return PathBuf::from(&artifact.filenames[0]);
                        }
                    }
                }
diff --git a/crates/project_model/Cargo.toml b/crates/project_model/Cargo.toml
index 293cb5bfe..fe3258332 100644
--- a/crates/project_model/Cargo.toml
+++ b/crates/project_model/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 log = "0.4.8"
 rustc-hash = "1.1.0"
-cargo_metadata = "0.12.2"
+cargo_metadata = "0.13"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_json = "1.0.48"
 anyhow = "1.0.26"
@@ -22,7 +22,7 @@ la-arena = { version = "0.2.0", path = "../../lib/arena" }
 cfg = { path = "../cfg", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 toolchain = { path = "../toolchain", version = "0.0.0" }
-proc_macro_api =  { path = "../proc_macro_api", version = "0.0.0" }
+proc_macro_api = { path = "../proc_macro_api", version = "0.0.0" }
-paths =  { path = "../paths", version = "0.0.0" }
+paths = { path = "../paths", version = "0.0.0" }
-stdx =  { path = "../stdx", version = "0.0.0" }
+stdx = { path = "../stdx", version = "0.0.0" }
-profile =  { path = "../profile", version = "0.0.0" }
+profile = { path = "../profile", version = "0.0.0" }
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 295b5f8ef..728a258ea 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -1,14 +1,14 @@
 //! Handles build script specific information
 use std::{
-    ffi::OsStr,
    io::BufReader,
-    path::{Path, PathBuf},
+    path::PathBuf,
    process::{Command, Stdio},
    sync::Arc,
 };
 use anyhow::Result;
+use cargo_metadata::camino::Utf8Path;
 use cargo_metadata::{BuildScript, Message};
 use itertools::Itertools;
 use paths::{AbsPath, AbsPathBuf};
@@ -162,8 +162,8 @@ fn collect_from_workspace(
                    let res = res.entry(package_id.repr.clone()).or_default();
                    // cargo_metadata crate returns default (empty) path for
                    // older cargos, which is not absolute, so work around that.
-                    if out_dir != PathBuf::default() {
+                    if !out_dir.as_str().is_empty() {
-                        let out_dir = AbsPathBuf::assert(out_dir);
+                        let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
                        res.out_dir = Some(out_dir);
                        res.cfgs = cfgs;
                    }
@@ -178,7 +178,7 @@ fn collect_from_workspace(
                        // Skip rmeta file
                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
                        {
-                            let filename = AbsPathBuf::assert(filename.clone());
+                            let filename = AbsPathBuf::assert(PathBuf::from(&filename));
                            let res = res.entry(package_id.repr.clone()).or_default();
                            res.proc_macro_dylib_path = Some(filename);
                        }
@@ -187,9 +187,9 @@ fn collect_from_workspace(
                Message::CompilerMessage(message) => {
                    progress(message.target.name.clone());
                }
-                Message::Unknown => (),
                Message::BuildFinished(_) => {}
                Message::TextLine(_) => {}
+                _ => {}
            }
        }
    }
@@ -209,8 +209,8 @@ fn collect_from_workspace(
 }
 // FIXME: File a better way to know if it is a dylib
-fn is_dylib(path: &Path) -> bool {
+fn is_dylib(path: &Utf8Path) -> bool {
-    match path.extension().and_then(OsStr::to_str).map(|it| it.to_string().to_lowercase()) {
+    match path.extension().map(|e| e.to_string().to_lowercase()) {
        None => false,
        Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"),
    }
@@ -227,9 +227,7 @@ fn inject_cargo_env(package: &cargo_metadata::Package, build_data: &mut BuildDat
    let mut manifest_dir = package.manifest_path.clone();
    manifest_dir.pop();
-    if let Some(cargo_manifest_dir) = manifest_dir.to_str() {
+    env.push(("CARGO_MANIFEST_DIR".into(), manifest_dir.into_string()));
-        env.push(("CARGO_MANIFEST_DIR".into(), cargo_manifest_dir.into()));
-    }
    // Not always right, but works for common cases.
    env.push(("CARGO".into(), "cargo".into()));
@@ -251,7 +249,6 @@ fn inject_cargo_env(package: &cargo_metadata::Package, build_data: &mut BuildDat
    env.push(("CARGO_PKG_REPOSITORY".into(), package.repository.clone().unwrap_or_default()));
    env.push(("CARGO_PKG_LICENSE".into(), package.license.clone().unwrap_or_default()));
-    let license_file =
+    let license_file = package.license_file.as_ref().map(|buf| buf.to_string()).unwrap_or_default();
-        package.license_file.as_ref().map(|buf| buf.display().to_string()).unwrap_or_default();
    env.push(("CARGO_PKG_LICENSE_FILE".into(), license_file));
 }
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index 1d8d34a0b..f7241b711 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -1,5 +1,6 @@
 //! FIXME: write short doc here
+use std::path::PathBuf;
 use std::{convert::TryInto, ops, process::Command, sync::Arc};
 use anyhow::{Context, Result};
@@ -249,11 +250,12 @@ impl CargoWorkspace {
            let edition = edition
                .parse::<Edition>()
                .with_context(|| format!("Failed to parse edition {}", edition))?;
            let pkg = packages.alloc(PackageData {
                id: id.repr.clone(),
                name: name.clone(),
                version: version.to_string(),
-                manifest: AbsPathBuf::assert(manifest_path.clone()),
+                manifest: AbsPathBuf::assert(PathBuf::from(&manifest_path)),
                targets: Vec::new(),
                is_member,
                edition,
@@ -268,7 +270,7 @@ impl CargoWorkspace {
                let tgt = targets.alloc(TargetData {
                    package: pkg,
                    name: meta_tgt.name.clone(),
-                    root: AbsPathBuf::assert(meta_tgt.src_path.clone()),
+                    root: AbsPathBuf::assert(PathBuf::from(&meta_tgt.src_path)),
                    kind: TargetKind::new(meta_tgt.kind.as_slice()),
                    is_proc_macro,
                });
@@ -305,7 +307,8 @@ impl CargoWorkspace {
            packages[source].active_features.extend(node.features);
        }
-        let workspace_root = AbsPathBuf::assert(meta.workspace_root);
+        let workspace_root =
+            AbsPathBuf::assert(PathBuf::from(meta.workspace_root.into_os_string()));
        let build_data_config = BuildDataConfig::new(
            cargo_toml.to_path_buf(),
            config.clone(),
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index b881cc229..8789f0852 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -24,7 +24,7 @@ jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.88.0", features = ["proposed"] }
 parking_lot = "0.11.0"
-pico-args = "0.4.0"
+xflags = "0.1.2"
 oorandom = "11.1.2"
 rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
deleted file mode 100644
index 164d94a30..000000000
--- a/crates/rust-analyzer/src/bin/args.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-//! Command like parsing for rust-analyzer.
-//!
-//! If run started args, we run the LSP server loop. With a subcommand, we do a
-//! one-time batch processing.
-use std::{env, path::PathBuf};
-use anyhow::{bail, format_err, Result};
-use ide_ssr::{SsrPattern, SsrRule};
-use pico_args::Arguments;
-use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
-use vfs::AbsPathBuf;
-pub(crate) struct Args {
-    pub(crate) verbosity: Verbosity,
-    pub(crate) log_file: Option<PathBuf>,
-    pub(crate) no_buffering: bool,
-    pub(crate) command: Command,
-    #[allow(unused)]
-    pub(crate) wait_dbg: bool,
-}
-pub(crate) enum Command {
-    Parse { no_dump: bool },
-    Symbols,
-    Highlight { rainbow: bool },
-    AnalysisStats(AnalysisStatsCmd),
-    Bench(BenchCmd),
-    Diagnostics { path: PathBuf, load_output_dirs: bool, with_proc_macro: bool },
-    Ssr { rules: Vec<SsrRule> },
-    StructuredSearch { debug_snippet: Option<String>, patterns: Vec<SsrPattern> },
-    ProcMacro,
-    RunServer,
-    PrintConfigSchema,
-    Version,
-    Help,
-}
-const HELP: &str = "\
-rust-analyzer
-USAGE:
-    rust-analyzer [FLAGS] [COMMAND] [COMMAND_OPTIONS]
-FLAGS:
-    --version         Print version
-    -h, --help        Print this help
-    -v,  --verbose
-    -vv, --spammy
-    -q,  --quiet      Set verbosity
-    --print-config-schema
-                      Dump a LSP config JSON schema
-    --log-file <PATH> Log to the specified file instead of stderr
-    --no-log-buffering
-                      Flush log records to the file immediately
-    --wait-dbg        Wait until a debugger is attached to.
-                      The flag is valid for debug builds only
-ENVIRONMENTAL VARIABLES:
-    RA_LOG            Set log filter in env_logger format
-    RA_PROFILE        Enable hierarchical profiler
-    RA_WAIT_DBG       If set acts like a --wait-dbg flag
-COMMANDS:
-not specified         Launch LSP server
-parse < main.rs       Parse tree
-    --no-dump         Suppress printing
-symbols < main.rs     Parse input an print the list of symbols
-highlight < main.rs   Highlight input as html
-    --rainbow         Enable rainbow highlighting of identifiers
-analysis-stats <PATH> Batch typecheck project and print summary statistics
-    <PATH>            Directory with Cargo.toml
-    --randomize       Randomize order in which crates, modules, and items are processed
-    --parallel        Run type inference in parallel
-    --memory-usage    Collect memory usage statistics
-    -o, --only <PATH> Only analyze items matching this path
-    --with-deps       Also analyze all dependencies
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-analysis-bench <PATH> Benchmark specific analysis operation
-    <PATH>            Directory with Cargo.toml
-    --highlight <PATH>
-                      Compute syntax highlighting for this file
-    --complete <PATH:LINE:COLUMN>
-                      Compute completions at this location
-    --goto-def <PATH:LINE:COLUMN>
-                      Compute goto definition at this location
-    --memory-usage    Collect memory usage statistics
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-diagnostics <PATH>
-    <PATH>            Directory with Cargo.toml
-    --load-output-dirs
-                      Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro Use proc-macro-srv for proc-macro expanding
-ssr [RULE...]
-    <RULE>            A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
-search [PATTERN..]
-    <PATTERN>         A structured search replace pattern (`$a.foo($b)`)
-    --debug <snippet> Prints debug information for any nodes with source exactly
-                      equal to <snippet>
-";
-impl Args {
-    pub(crate) fn parse() -> Result<Args> {
-        let mut matches = Arguments::from_env();
-        if matches.contains("--version") {
-            finish_args(matches)?;
-            return Ok(Args {
-                verbosity: Verbosity::Normal,
-                log_file: None,
-                command: Command::Version,
-                no_buffering: false,
-                wait_dbg: false,
-            });
-        }
-        let verbosity = match (
-            matches.contains(["-vv", "--spammy"]),
-            matches.contains(["-v", "--verbose"]),
-            matches.contains(["-q", "--quiet"]),
-        ) {
-            (true, _, true) => bail!("Invalid flags: -q conflicts with -vv"),
-            (true, _, false) => Verbosity::Spammy,
-            (false, false, false) => Verbosity::Normal,
-            (false, false, true) => Verbosity::Quiet,
-            (false, true, false) => Verbosity::Verbose,
-            (false, true, true) => bail!("Invalid flags: -q conflicts with -v"),
-        };
-        let log_file = matches.opt_value_from_str("--log-file")?;
-        let no_buffering = matches.contains("--no-log-buffering");
-        let wait_dbg = matches.contains("--wait-dbg");
-        if matches.contains(["-h", "--help"]) {
-            eprintln!("{}", HELP);
-            return Ok(Args {
-                verbosity,
-                log_file: None,
-                command: Command::Help,
-                no_buffering,
-                wait_dbg,
-            });
-        }
-        if matches.contains("--print-config-schema") {
-            return Ok(Args {
-                verbosity,
-                log_file,
-                command: Command::PrintConfigSchema,
-                no_buffering,
-                wait_dbg,
-            });
-        }
-        let subcommand = match matches.subcommand()? {
-            Some(it) => it,
-            None => {
-                finish_args(matches)?;
-                return Ok(Args {
-                    verbosity,
-                    log_file,
-                    command: Command::RunServer,
-                    no_buffering,
-                    wait_dbg,
-                });
-            }
-        };
-        let command = match subcommand.as_str() {
-            "parse" => Command::Parse { no_dump: matches.contains("--no-dump") },
-            "symbols" => Command::Symbols,
-            "highlight" => Command::Highlight { rainbow: matches.contains("--rainbow") },
-            "analysis-stats" => Command::AnalysisStats(AnalysisStatsCmd {
-                randomize: matches.contains("--randomize"),
-                parallel: matches.contains("--parallel"),
-                memory_usage: matches.contains("--memory-usage"),
-                only: matches.opt_value_from_str(["-o", "--only"])?,
-                with_deps: matches.contains("--with-deps"),
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            }),
-            "analysis-bench" => Command::Bench(BenchCmd {
-                what: {
-                    let highlight_path: Option<String> =
-                        matches.opt_value_from_str("--highlight")?;
-                    let complete_path: Option<Position> =
-                        matches.opt_value_from_str("--complete")?;
-                    let goto_def_path: Option<Position> =
-                        matches.opt_value_from_str("--goto-def")?;
-                    match (highlight_path, complete_path, goto_def_path) {
-                            (Some(path), None, None) => {
-                                let path = env::current_dir().unwrap().join(path);
-                                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
-                            }
-                            (None, Some(position), None) => BenchWhat::Complete(position),
-                            (None, None, Some(position)) => BenchWhat::GotoDef(position),
-                            _ => panic!(
-                                "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
-                            ),
-                        }
-                },
-                memory_usage: matches.contains("--memory-usage"),
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            }),
-            "diagnostics" => Command::Diagnostics {
-                load_output_dirs: matches.contains("--load-output-dirs"),
-                with_proc_macro: matches.contains("--with-proc-macro"),
-                path: matches
-                    .opt_free_from_str()?
-                    .ok_or_else(|| format_err!("expected positional argument"))?,
-            },
-            "proc-macro" => Command::ProcMacro,
-            "ssr" => Command::Ssr {
-                rules: {
-                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.opt_free_from_str()? {
-                        acc.push(rule);
-                    }
-                    acc
-                },
-            },
-            "search" => Command::StructuredSearch {
-                debug_snippet: matches.opt_value_from_str("--debug")?,
-                patterns: {
-                    let mut acc = Vec::new();
-                    while let Some(rule) = matches.opt_free_from_str()? {
-                        acc.push(rule);
-                    }
-                    acc
-                },
-            },
-            _ => {
-                eprintln!("{}", HELP);
-                return Ok(Args {
-                    verbosity,
-                    log_file: None,
-                    command: Command::Help,
-                    no_buffering,
-                    wait_dbg,
-                });
-            }
-        };
-        finish_args(matches)?;
-        Ok(Args { verbosity, log_file, command, no_buffering, wait_dbg })
-    }
-}
-fn finish_args(args: Arguments) -> Result<()> {
-    if !args.finish().is_empty() {
-        bail!("Unused arguments.");
-    }
-    Ok(())
-}
diff --git a/crates/rust-analyzer/src/bin/flags.rs b/crates/rust-analyzer/src/bin/flags.rs
new file mode 100644
index 000000000..244912d26
--- /dev/null
+++ b/crates/rust-analyzer/src/bin/flags.rs
@@ -0,0 +1,251 @@
+//! Grammar for the command-line arguments.
+#![allow(unreachable_pub)]
+use std::{env, path::PathBuf};
+use ide_ssr::{SsrPattern, SsrRule};
+use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
+use vfs::AbsPathBuf;
+xflags::args_parser! {
+    /// LSP server for the Rust programming language.
+    cmd rust-analyzer {
+        /// Verbosity level, can be repeated multiple times.
+        repeated -v, --verbose
+        /// Verbosity level.
+        optional -q, --quiet
+        /// Log to the specified file instead of stderr.
+        optional --log-file path: PathBuf
+        /// Flush log records to the file immediately.
+        optional --no-log-buffering
+        /// Wait until a debugger is attached to (requires debug build).
+        optional --wait-dbg
+        default cmd lsp-server {
+            /// Print version.
+            optional --version
+            /// Print help.
+            optional -h, --help
+            /// Dump a LSP config JSON schema.
+            optional --print-config-schema
+        }
+        /// Parse stdin.
+        cmd parse {
+            /// Suppress printing.
+            optional --no-dump
+        }
+        /// Parse stdin and print the list of symbols.
+        cmd symbols {}
+        /// Highlight stdin as html.
+        cmd highlight {
+            /// Enable rainbow highlighting of identifiers.
+            optional --rainbow
+        }
+        /// Batch typecheck project and print summary statistics
+        cmd analysis-stats
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Randomize order in which crates, modules, and items are processed.
+            optional --randomize
+            /// Run type inference in parallel.
+            optional --parallel
+            /// Collect memory usage statistics.
+            optional --memory-usage
+            /// Only analyze items matching this path.
+            optional -o, --only path: String
+            /// Also analyze all dependencies.
+            optional --with-deps
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+        /// Benchmark specific analysis operation
+        cmd analysis-bench
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Collect memory usage statistics.
+            optional --memory-usage
+            /// Compute syntax highlighting for this file
+            optional --highlight path: PathBuf
+            /// Compute completions at file:line:column location.
+            optional --complete location: Position
+            /// Compute goto definition at file:line:column location.
+            optional --goto-def location: Position
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+        cmd diagnostics
+            /// Directory with Cargo.toml.
+            required path: PathBuf
+        {
+            /// Load OUT_DIR values by running `cargo check` before analysis.
+            optional --load-output-dirs
+            /// Use proc-macro-srv for proc-macro expanding.
+            optional --with-proc-macro
+        }
+        cmd ssr
+            /// A structured search replace rule (`$a.foo($b) ==> bar($a, $b)`)
+            repeated rule: SsrRule
+        {}
+        cmd search
+            /// A structured search replace pattern (`$a.foo($b)`)
+            repeated pattern: SsrPattern
+        {
+            /// Prints debug information for any nodes with source exactly equal to snippet.
+            optional --debug snippet: String
+        }
+        cmd proc-macro {}
+    }
+}
+// generated start
+// The following code is generated by `xflags` macro.
+// Run `env XFLAGS_DUMP= cargo build` to regenerate.
+#[derive(Debug)]
+pub struct RustAnalyzer {
+    pub verbose: u32,
+    pub quiet: bool,
+    pub log_file: Option<PathBuf>,
+    pub no_log_buffering: bool,
+    pub wait_dbg: bool,
+    pub subcommand: RustAnalyzerCmd,
+}
+#[derive(Debug)]
+pub enum RustAnalyzerCmd {
+    LspServer(LspServer),
+    Parse(Parse),
+    Symbols(Symbols),
+    Highlight(Highlight),
+    AnalysisStats(AnalysisStats),
+    AnalysisBench(AnalysisBench),
+    Diagnostics(Diagnostics),
+    Ssr(Ssr),
+    Search(Search),
+    ProcMacro(ProcMacro),
+}
+#[derive(Debug)]
+pub struct LspServer {
+    pub version: bool,
+    pub help: bool,
+    pub print_config_schema: bool,
+}
+#[derive(Debug)]
+pub struct Parse {
+    pub no_dump: bool,
+}
+#[derive(Debug)]
+pub struct Symbols {}
+#[derive(Debug)]
+pub struct Highlight {
+    pub rainbow: bool,
+}
+#[derive(Debug)]
+pub struct AnalysisStats {
+    pub path: PathBuf,
+    pub randomize: bool,
+    pub parallel: bool,
+    pub memory_usage: bool,
+    pub only: Option<String>,
+    pub with_deps: bool,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+#[derive(Debug)]
+pub struct AnalysisBench {
+    pub path: PathBuf,
+    pub memory_usage: bool,
+    pub highlight: Option<PathBuf>,
+    pub complete: Option<Position>,
+    pub goto_def: Option<Position>,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+#[derive(Debug)]
+pub struct Diagnostics {
+    pub path: PathBuf,
+    pub load_output_dirs: bool,
+    pub with_proc_macro: bool,
+}
+#[derive(Debug)]
+pub struct Ssr {
+    pub rule: Vec<SsrRule>,
+}
+#[derive(Debug)]
+pub struct Search {
+    pub pattern: Vec<SsrPattern>,
+    pub debug: Option<String>,
+}
+#[derive(Debug)]
+pub struct ProcMacro {}
+impl RustAnalyzer {
+    pub const HELP: &'static str = Self::_HELP;
+    pub fn from_env() -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new_from_env();
+        Self::_parse(&mut p)
+    }
+}
+// generated end
+impl RustAnalyzer {
+    pub(crate) fn verbosity(&self) -> Verbosity {
+        if self.quiet {
+            return Verbosity::Quiet;
+        }
+        match self.verbose {
+            0 => Verbosity::Normal,
+            1 => Verbosity::Verbose,
+            _ => Verbosity::Spammy,
+        }
+    }
+}
+impl AnalysisBench {
+    pub(crate) fn what(&self) -> BenchWhat {
+        match (&self.highlight, &self.complete, &self.goto_def) {
+            (Some(path), None, None) => {
+                let path = env::current_dir().unwrap().join(path);
+                BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
+            }
+            (None, Some(position), None) => BenchWhat::Complete(position.clone()),
+            (None, None, Some(position)) => BenchWhat::GotoDef(position.clone()),
+            _ => panic!("exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"),
+        }
+    }
+}
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 89482b952..288847980 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -1,14 +1,20 @@
 //! Driver for rust-analyzer.
 //!
 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
-mod args;
+mod flags;
 mod logger;
-use std::{convert::TryFrom, env, fs, path::PathBuf, process};
+use std::{convert::TryFrom, env, fs, path::Path, process};
 use lsp_server::Connection;
 use project_model::ProjectManifest;
-use rust_analyzer::{cli, config::Config, from_json, lsp_ext::supports_utf8, Result};
+use rust_analyzer::{
+    cli::{self, AnalysisStatsCmd, BenchCmd},
+    config::Config,
+    from_json,
+    lsp_ext::supports_utf8,
+    Result,
+};
 use vfs::AbsPathBuf;
 #[cfg(all(feature = "mimalloc"))]
@@ -28,10 +34,10 @@ fn main() {
 }
 fn try_main() -> Result<()> {
-    let args = args::Args::parse()?;
+    let flags = flags::RustAnalyzer::from_env()?;
    #[cfg(debug_assertions)]
-    if args.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
+    if flags.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
        #[allow(unused_mut)]
        let mut d = 4;
        while d == 4 {
@@ -39,35 +45,62 @@ fn try_main() -> Result<()> {
        }
    }
-    setup_logging(args.log_file, args.no_buffering)?;
+    setup_logging(flags.log_file.as_deref(), flags.no_log_buffering)?;
-    match args.command {
+    let verbosity = flags.verbosity();
-        args::Command::RunServer => run_server()?,
-        args::Command::PrintConfigSchema => {
+    match flags.subcommand {
-            println!("{:#}", Config::json_schema());
+        flags::RustAnalyzerCmd::LspServer(cmd) => {
+            if cmd.print_config_schema {
+                println!("{:#}", Config::json_schema());
+                return Ok(());
+            }
+            if cmd.version {
+                println!("rust-analyzer {}", env!("REV"));
+                return Ok(());
+            }
+            if cmd.help {
+                println!("{}", flags::RustAnalyzer::HELP);
+                return Ok(());
+            }
+            run_server()?
        }
-        args::Command::ProcMacro => proc_macro_srv::cli::run()?,
+        flags::RustAnalyzerCmd::ProcMacro(_) => proc_macro_srv::cli::run()?,
+        flags::RustAnalyzerCmd::Parse(cmd) => cli::parse(cmd.no_dump)?,
-        args::Command::Parse { no_dump } => cli::parse(no_dump)?,
+        flags::RustAnalyzerCmd::Symbols(_) => cli::symbols()?,
-        args::Command::Symbols => cli::symbols()?,
+        flags::RustAnalyzerCmd::Highlight(cmd) => cli::highlight(cmd.rainbow)?,
-        args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
+        flags::RustAnalyzerCmd::AnalysisStats(cmd) => AnalysisStatsCmd {
-        args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
+            randomize: cmd.randomize,
-        args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
+            parallel: cmd.parallel,
-        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro } => {
+            memory_usage: cmd.memory_usage,
-            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro)?
+            only: cmd.only,
+            with_deps: cmd.with_deps,
+            path: cmd.path,
+            load_output_dirs: cmd.load_output_dirs,
+            with_proc_macro: cmd.with_proc_macro,
        }
-        args::Command::Ssr { rules } => {
+        .run(verbosity)?,
-            cli::apply_ssr_rules(rules)?;
+        flags::RustAnalyzerCmd::AnalysisBench(cmd) => {
+            let what = cmd.what();
+            BenchCmd {
+                memory_usage: cmd.memory_usage,
+                path: cmd.path,
+                load_output_dirs: cmd.load_output_dirs,
+                with_proc_macro: cmd.with_proc_macro,
+                what,
+            }
+            .run(verbosity)?
        }
-        args::Command::StructuredSearch { patterns, debug_snippet } => {
-            cli::search_for_patterns(patterns, debug_snippet)?;
+        flags::RustAnalyzerCmd::Diagnostics(cmd) => {
+            cli::diagnostics(&cmd.path, cmd.load_output_dirs, cmd.with_proc_macro)?
        }
-        args::Command::Version => println!("rust-analyzer {}", env!("REV")),
+        flags::RustAnalyzerCmd::Ssr(cmd) => cli::apply_ssr_rules(cmd.rule)?,
-        args::Command::Help => {}
+        flags::RustAnalyzerCmd::Search(cmd) => cli::search_for_patterns(cmd.pattern, cmd.debug)?,
    }
    Ok(())
 }
-fn setup_logging(log_file: Option<PathBuf>, no_buffering: bool) -> Result<()> {
+fn setup_logging(log_file: Option<&Path>, no_buffering: bool) -> Result<()> {
    env::set_var("RUST_BACKTRACE", "short");
    let log_file = match log_file {
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 8991f3bdb..3bd7e678d 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -35,6 +35,7 @@ pub enum BenchWhat {
    GotoDef(Position),
 }
+#[derive(Debug, Clone)]
 pub struct Position {
    pub path: AbsPathBuf,
    pub line: u32,
@@ -68,7 +69,7 @@ impl BenchCmd {
            load_out_dirs_from_check: self.load_output_dirs,
            with_proc_macro: self.with_proc_macro,
        };
-        let (mut host, vfs) =
+        let (mut host, vfs, _proc_macro) =
            load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
        eprintln!("{:?}\n", start.elapsed());
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 9072d8944..ad0759bda 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -64,7 +64,7 @@ impl AnalysisStatsCmd {
            load_out_dirs_from_check: self.load_output_dirs,
            with_proc_macro: self.with_proc_macro,
        };
-        let (host, vfs) =
+        let (host, vfs, _proc_macro) =
            load_workspace_at(&self.path, &cargo_config, &load_cargo_config, &|_| {})?;
        let db = host.raw_database();
        eprintln!("{:<20} {}", "Database loaded:", db_load_sw.elapsed());
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index 876f6c44f..8b985716b 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -35,7 +35,8 @@ pub fn diagnostics(
 ) -> Result<()> {
    let cargo_config = Default::default();
    let load_cargo_config = LoadCargoConfig { load_out_dirs_from_check, with_proc_macro };
-    let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
+    let (host, _vfs, _proc_macro) =
+        load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
    let db = host.raw_database();
    let analysis = host.analysis();
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 23442afac..310c36904 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -23,7 +23,7 @@ pub fn load_workspace_at(
    cargo_config: &CargoConfig,
    load_config: &LoadCargoConfig,
    progress: &dyn Fn(String),
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+) -> Result<(AnalysisHost, vfs::Vfs, Option<ProcMacroClient>)> {
    let root = AbsPathBuf::assert(std::env::current_dir()?.join(root));
    let root = ProjectManifest::discover_single(&root)?;
    let workspace = ProjectWorkspace::load(root, cargo_config, progress)?;
@@ -35,7 +35,7 @@ pub fn load_workspace(
    ws: ProjectWorkspace,
    config: &LoadCargoConfig,
    progress: &dyn Fn(String),
-) -> Result<(AnalysisHost, vfs::Vfs)> {
+) -> Result<(AnalysisHost, vfs::Vfs, Option<ProcMacroClient>)> {
    let (sender, receiver) = unbounded();
    let mut vfs = vfs::Vfs::default();
    let mut loader = {
@@ -80,7 +80,7 @@ pub fn load_workspace(
    log::debug!("crate graph: {:?}", crate_graph);
    let host =
        load_crate_graph(crate_graph, project_folders.source_root_config, &mut vfs, &receiver);
-    Ok((host, vfs))
+    Ok((host, vfs, proc_macro_client))
 }
 fn load_crate_graph(
@@ -138,7 +138,8 @@ mod tests {
        let cargo_config = Default::default();
        let load_cargo_config =
            LoadCargoConfig { load_out_dirs_from_check: false, with_proc_macro: false };
-        let (host, _vfs) = load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
+        let (host, _vfs, _proc_macro) =
+            load_workspace_at(path, &cargo_config, &load_cargo_config, &|_| {})?;
        let n_crates = Crate::all(host.raw_database()).len();
        // RA has quite a few crates, but the exact count doesn't matter
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
index 71a8f8fb9..79f426fff 100644
--- a/crates/rust-analyzer/src/cli/ssr.rs
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -11,7 +11,7 @@ pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
    let cargo_config = Default::default();
    let load_cargo_config =
        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
-    let (host, vfs) =
+    let (host, vfs, _proc_macro) =
        load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
    let db = host.raw_database();
    let mut match_finder = MatchFinder::at_first_file(db)?;
@@ -38,7 +38,7 @@ pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<Stri
    let cargo_config = Default::default();
    let load_cargo_config =
        LoadCargoConfig { load_out_dirs_from_check: true, with_proc_macro: true };
-    let (host, _vfs) =
+    let (host, _vfs, _proc_macro) =
        load_workspace_at(&std::env::current_dir()?, &cargo_config, &load_cargo_config, &|_| {})?;
    let db = host.raw_database();
    let mut match_finder = MatchFinder::at_first_file(db)?;
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 0ed87fe3e..0ad832c0e 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -29,7 +29,7 @@ fn diagnostic_severity(
        },
        DiagnosticLevel::Note => lsp_types::DiagnosticSeverity::Information,
        DiagnosticLevel::Help => lsp_types::DiagnosticSeverity::Hint,
-        DiagnosticLevel::Unknown => return None,
+        _ => return None,
    };
    Some(res)
 }
diff --git a/crates/rust-analyzer/tests/rust-analyzer/main.rs b/crates/rust-analyzer/tests/rust-analyzer/main.rs
index 80bde29b9..7545b4a34 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/main.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/main.rs
@@ -54,7 +54,9 @@ version = "0.0.0"
 use std::collections::Spam;
 "#,
    )
-    .with_sysroot(true)
+    .with_config(serde_json::json!({
+        "cargo": { "noSysroot": false }
+    }))
    .server()
    .wait_until_workspace_is_loaded();
@@ -451,7 +453,9 @@ fn main() {{}}
 "#,
        librs, libs
    ))
-    .with_sysroot(true)
+    .with_config(serde_json::json!({
+        "cargo": { "noSysroot": false }
+    }))
    .server()
    .wait_until_workspace_is_loaded();
@@ -574,7 +578,10 @@ fn main() {
 "###,
    )
    .with_config(serde_json::json!({
-        "cargo": { "loadOutDirsFromCheck": true }
+        "cargo": {
+            "loadOutDirsFromCheck": true,
+            "noSysroot": true,
+        }
    }))
    .server()
    .wait_until_workspace_is_loaded();
@@ -717,7 +724,10 @@ pub fn foo(_input: TokenStream) -> TokenStream {
 "###,
    )
    .with_config(serde_json::json!({
-        "cargo": { "loadOutDirsFromCheck": true },
+        "cargo": {
+            "loadOutDirsFromCheck": true,
+            "noSysroot": true,
+        },
        "procMacro": {
            "enable": true,
            "server": PathBuf::from(env!("CARGO_BIN_EXE_rust-analyzer")),
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index 453ce4fa8..6b774073d 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -20,7 +20,6 @@ use crate::testdir::TestDir;
 pub(crate) struct Project<'a> {
    fixture: &'a str,
-    with_sysroot: bool,
    tmp_dir: Option<TestDir>,
    roots: Vec<PathBuf>,
    config: serde_json::Value,
@@ -32,8 +31,10 @@ impl<'a> Project<'a> {
            fixture,
            tmp_dir: None,
            roots: vec![],
-            with_sysroot: false,
+            config: serde_json::json!({
-            config: serde_json::Value::Null,
+                // Loading standard library is costly, let's ignore it by default
+                "cargo": { "noSysroot": true }
+            }),
        }
    }
@@ -47,11 +48,6 @@ impl<'a> Project<'a> {
        self
    }
-    pub(crate) fn with_sysroot(mut self, yes: bool) -> Project<'a> {
-        self.with_sysroot = yes;
-        self
-    }
    pub(crate) fn with_config(mut self, config: serde_json::Value) -> Project<'a> {
        self.config = config;
        self
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 824ebf41c..0b3b76d4a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -595,11 +595,14 @@ impl ops::Add<u8> for IndentLevel {
 impl IndentLevel {
    pub fn from_node(node: &SyntaxNode) -> IndentLevel {
-        let first_token = match node.first_token() {
+        match node.first_token() {
-            Some(it) => it,
+            Some(it) => Self::from_token(&it),
            None => return IndentLevel(0),
-        };
+        }
-        for ws in prev_tokens(first_token).filter_map(ast::Whitespace::cast) {
+    }
+    pub fn from_token(token: &SyntaxToken) -> IndentLevel {
+        for ws in prev_tokens(token.clone()).filter_map(ast::Whitespace::cast) {
            let text = ws.syntax().text();
            if let Some(pos) = text.rfind('\n') {
                let level = text[pos + 1..].chars().count() / 4;
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 044e3e5e8..977eb8181 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -85,8 +85,9 @@ pub enum CommentPlacement {
 }
 impl CommentKind {
-    const BY_PREFIX: [(&'static str, CommentKind); 8] = [
+    const BY_PREFIX: [(&'static str, CommentKind); 9] = [
        ("/**/", CommentKind { shape: CommentShape::Block, doc: None }),
+        ("/***", CommentKind { shape: CommentShape::Block, doc: None }),
        ("////", CommentKind { shape: CommentShape::Line, doc: None }),
        ("///", CommentKind { shape: CommentShape::Line, doc: Some(CommentPlacement::Outer) }),
        ("//!", CommentKind { shape: CommentShape::Line, doc: Some(CommentPlacement::Inner) }),