69 files changed, 9208 insertions, 1770 deletions
diff --git a/crates/base_db/src/change.rs b/crates/base_db/src/change.rs
index 043e03bba..04e294e41 100644
--- a/crates/base_db/src/change.rs
+++ b/crates/base_db/src/change.rs
@@ -19,7 +19,7 @@ pub struct Change {
 impl fmt::Debug for Change {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let mut d = fmt.debug_struct("AnalysisChange");
+        let mut d = fmt.debug_struct("Change");
        if let Some(roots) = &self.roots {
            d.field("roots", roots);
        }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index b3218833d..00b0dc082 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -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, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment,
-    TyDefId, TyKind, TypeCtor,
+    Ty, TyDefId, TyVariableKind,
 };
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
@@ -1547,25 +1547,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 +1648,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 +1679,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 +1688,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 +1709,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 +1718,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 +1782,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 +1878,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 +1924,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 +1953,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 +1974,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/diagnostics.rs b/crates/hir/src/diagnostics.rs
index 5343a036c..b1ebba516 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -1,5 +1,7 @@
 //! FIXME: write short doc here
-pub use hir_def::diagnostics::{InactiveCode, UnresolvedModule, UnresolvedProcMacro};
+pub use hir_def::diagnostics::{
+    InactiveCode, UnresolvedMacroCall, UnresolvedModule, UnresolvedProcMacro,
+};
 pub use hir_expand::diagnostics::{
    Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder,
 };
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 59292d5a2..144851f83 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -16,13 +16,12 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, GenericParamsOwner, LoopBodyOwner},
-    match_ast, AstNode, SyntaxNode, SyntaxToken, TextSize,
+    match_ast, AstNode, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextSize,
 };
 use crate::{
    code_model::Access,
    db::HirDatabase,
-    diagnostics::Diagnostic,
    semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
    source_analyzer::{resolve_hir_path, SourceAnalyzer},
    AssocItem, Callable, ConstParam, Crate, Field, Function, HirFileId, Impl, InFile, Label,
@@ -141,7 +140,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.original_range(node)
    }
-    pub fn diagnostics_display_range(&self, diagnostics: &dyn Diagnostic) -> FileRange {
+    pub fn diagnostics_display_range(&self, diagnostics: InFile<SyntaxNodePtr>) -> FileRange {
        self.imp.diagnostics_display_range(diagnostics)
    }
@@ -385,8 +384,7 @@ impl<'db> SemanticsImpl<'db> {
        node.as_ref().original_file_range(self.db.upcast())
    }
-    fn diagnostics_display_range(&self, diagnostics: &dyn Diagnostic) -> FileRange {
+    fn diagnostics_display_range(&self, src: InFile<SyntaxNodePtr>) -> FileRange {
-        let src = diagnostics.display_source();
        let root = self.db.parse_or_expand(src.file_id).unwrap();
        let node = src.value.to_node(&root);
        self.cache(root, src.file_id);
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.rs b/crates/hir_def/src/body.rs
index 9a432f7d1..ff4b4a0cf 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -123,7 +123,7 @@ impl Expander {
            Some(it) => it,
            None => {
                if err.is_none() {
-                    eprintln!("no error despite `as_call_id_with_errors` returning `None`");
+                    log::warn!("no error despite `as_call_id_with_errors` returning `None`");
                }
                return ExpandResult { value: None, err };
            }
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/body/tests/block.rs b/crates/hir_def/src/body/tests/block.rs
index a5ec0883f..8bca72a17 100644
--- a/crates/hir_def/src/body/tests/block.rs
+++ b/crates/hir_def/src/body/tests/block.rs
@@ -259,3 +259,32 @@ fn main() {
    "#]],
    );
 }
+#[test]
+fn underscore_import() {
+    // This used to panic, because the default (private) visibility inside block expressions would
+    // point into the containing `DefMap`, which visibilities should never be able to do.
+    mark::check!(adjust_vis_in_block_def_map);
+    check_at(
+        r#"
+mod m {
+    fn main() {
+        use Tr as _;
+        trait Tr {}
+        $0
+    }
+}
+    "#,
+        expect![[r#"
+        block scope
+        _: t
+        Tr: t
+        crate
+        m: t
+        crate::m
+        main: v
+    "#]],
+    );
+}
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/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index ab3f059ce..ac7474f63 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -95,6 +95,34 @@ impl Diagnostic for UnresolvedImport {
    }
 }
+// Diagnostic: unresolved-macro-call
+//
+// This diagnostic is triggered if rust-analyzer is unable to resolove path to a
+// macro in a macro invocation.
+#[derive(Debug)]
+pub struct UnresolvedMacroCall {
+    pub file: HirFileId,
+    pub node: AstPtr<ast::MacroCall>,
+}
+impl Diagnostic for UnresolvedMacroCall {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-macro-call")
+    }
+    fn message(&self) -> String {
+        "unresolved macro call".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+    fn is_experimental(&self) -> bool {
+        true
+    }
+}
 // Diagnostic: inactive-code
 //
 // This diagnostic is shown for code with inactive `#[cfg]` attributes.
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/lib.rs b/crates/hir_def/src/lib.rs
index b50923747..6802bc250 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -57,8 +57,10 @@ use std::{
 use base_db::{impl_intern_key, salsa, CrateId};
 use hir_expand::{
-    ast_id_map::FileAstId, eager::expand_eager_macro, hygiene::Hygiene, AstId, HirFileId, InFile,
+    ast_id_map::FileAstId,
-    MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    eager::{expand_eager_macro, ErrorEmitted},
+    hygiene::Hygiene,
+    AstId, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use la_arena::Idx;
 use nameres::DefMap;
@@ -592,8 +594,15 @@ impl AsMacroCall for InFile<&ast::MacroCall> {
            error_sink(mbe::ExpandError::Other("malformed macro invocation".into()));
        }
-        AstIdWithPath::new(ast_id.file_id, ast_id.value, path?)
+        macro_call_as_call_id(
-            .as_call_id_with_errors(db, krate, resolver, error_sink)
+            &AstIdWithPath::new(ast_id.file_id, ast_id.value, path?),
+            db,
+            krate,
+            resolver,
+            error_sink,
+        )
+        .ok()?
+        .ok()
    }
 }
@@ -610,61 +619,50 @@ impl<T: ast::AstNode> AstIdWithPath<T> {
    }
 }
-impl AsMacroCall for AstIdWithPath<ast::MacroCall> {
+struct UnresolvedMacro;
-    fn as_call_id_with_errors(
-        &self,
+fn macro_call_as_call_id(
-        db: &dyn db::DefDatabase,
+    call: &AstIdWithPath<ast::MacroCall>,
-        krate: CrateId,
+    db: &dyn db::DefDatabase,
-        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    krate: CrateId,
-        error_sink: &mut dyn FnMut(mbe::ExpandError),
+    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
-    ) -> Option<MacroCallId> {
+    error_sink: &mut dyn FnMut(mbe::ExpandError),
-        let def: MacroDefId = resolver(self.path.clone()).or_else(|| {
+) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro> {
-            error_sink(mbe::ExpandError::Other(format!("could not resolve macro `{}`", self.path)));
+    let def: MacroDefId = resolver(call.path.clone()).ok_or(UnresolvedMacro)?;
-            None
-        })?;
+    let res = if let MacroDefKind::BuiltInEager(_) = def.kind {
+        let macro_call = InFile::new(call.ast_id.file_id, call.ast_id.to_node(db.upcast()));
-        if let MacroDefKind::BuiltInEager(_) = def.kind {
+        let hygiene = Hygiene::new(db.upcast(), call.ast_id.file_id);
-            let macro_call = InFile::new(self.ast_id.file_id, self.ast_id.to_node(db.upcast()));
-            let hygiene = Hygiene::new(db.upcast(), self.ast_id.file_id);
+        expand_eager_macro(
+            db.upcast(),
-            Some(
+            krate,
-                expand_eager_macro(
+            macro_call,
-                    db.upcast(),
+            def,
-                    krate,
+            &|path: ast::Path| resolver(path::ModPath::from_src(path, &hygiene)?),
-                    macro_call,
+            error_sink,
-                    def,
+        )
-                    &|path: ast::Path| resolver(path::ModPath::from_src(path, &hygiene)?),
+        .map(MacroCallId::from)
-                    error_sink,
+    } else {
-                )
+        Ok(def.as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike(call.ast_id)).into())
-                .ok()?
+    };
-                .into(),
+    Ok(res)
-            )
-        } else {
-            Some(def.as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike(self.ast_id)).into())
-        }
-    }
 }
-impl AsMacroCall for AstIdWithPath<ast::Item> {
+fn item_attr_as_call_id(
-    fn as_call_id_with_errors(
+    item_attr: &AstIdWithPath<ast::Item>,
-        &self,
+    db: &dyn db::DefDatabase,
-        db: &dyn db::DefDatabase,
+    krate: CrateId,
-        krate: CrateId,
+    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
-        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+) -> Result<MacroCallId, UnresolvedMacro> {
-        error_sink: &mut dyn FnMut(mbe::ExpandError),
+    let def: MacroDefId = resolver(item_attr.path.clone()).ok_or(UnresolvedMacro)?;
-    ) -> Option<MacroCallId> {
+    let last_segment = item_attr.path.segments().last().ok_or(UnresolvedMacro)?;
-        let def: MacroDefId = resolver(self.path.clone()).or_else(|| {
+    let res = def
-            error_sink(mbe::ExpandError::Other(format!("could not resolve macro `{}`", self.path)));
+        .as_lazy_macro(
-            None
+            db.upcast(),
-        })?;
+            krate,
+            MacroCallKind::Attr(item_attr.ast_id, last_segment.to_string()),
-        Some(
-            def.as_lazy_macro(
-                db.upcast(),
-                krate,
-                MacroCallKind::Attr(self.ast_id, self.path.segments().last()?.to_string()),
-            )
-            .into(),
        )
-    }
+        .into();
+    Ok(res)
 }
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index f92232eb3..6a3456f2e 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -417,6 +417,8 @@ mod diagnostics {
        UnresolvedProcMacro { ast: MacroCallKind },
+        UnresolvedMacroCall { ast: AstId<ast::MacroCall> },
        MacroError { ast: MacroCallKind, message: String },
    }
@@ -477,6 +479,13 @@ mod diagnostics {
            Self { in_module: container, kind: DiagnosticKind::MacroError { ast, message } }
        }
+        pub(super) fn unresolved_macro_call(
+            container: LocalModuleId,
+            ast: AstId<ast::MacroCall>,
+        ) -> Self {
+            Self { in_module: container, kind: DiagnosticKind::UnresolvedMacroCall { ast } }
+        }
        pub(super) fn add_to(
            &self,
            db: &dyn DefDatabase,
@@ -589,6 +598,11 @@ mod diagnostics {
                    });
                }
+                DiagnosticKind::UnresolvedMacroCall { ast } => {
+                    let node = ast.to_node(db.upcast());
+                    sink.push(UnresolvedMacroCall { file: ast.file_id, node: AstPtr::new(&node) });
+                }
                DiagnosticKind::MacroError { ast, message } => {
                    let (file, ast) = match ast {
                        MacroCallKind::FnLike(ast) => {
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 9996a0807..e51d89b43 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -13,7 +13,7 @@ use hir_expand::{
    builtin_macro::find_builtin_macro,
    name::{AsName, Name},
    proc_macro::ProcMacroExpander,
-    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -24,11 +24,13 @@ use tt::{Leaf, TokenTree};
 use crate::{
    attr::Attrs,
    db::DefDatabase,
+    item_attr_as_call_id,
    item_scope::{ImportType, PerNsGlobImports},
    item_tree::{
        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind,
        StructDefKind,
    },
+    macro_call_as_call_id,
    nameres::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
        BuiltinShadowMode, DefMap, ModuleData, ModuleOrigin, ResolveMode,
@@ -36,9 +38,9 @@ use crate::{
    path::{ImportAlias, ModPath, PathKind},
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
-    AdtId, AsMacroCall, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId,
+    AdtId, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc,
-    FunctionLoc, ImplLoc, Intern, LocalModuleId, ModuleDefId, StaticLoc, StructLoc, TraitLoc,
+    ImplLoc, Intern, LocalModuleId, ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc,
-    TypeAliasLoc, UnionLoc,
+    UnionLoc, UnresolvedMacro,
 };
 const GLOB_RECURSION_LIMIT: usize = 100;
@@ -790,8 +792,11 @@ impl DefCollector<'_> {
                return false;
            }
-            if let Some(call_id) =
+            match macro_call_as_call_id(
-                directive.ast_id.as_call_id(self.db, self.def_map.krate, |path| {
+                &directive.ast_id,
+                self.db,
+                self.def_map.krate,
+                |path| {
                    let resolved_res = self.def_map.resolve_path_fp_with_macro(
                        self.db,
                        ResolveMode::Other,
@@ -800,24 +805,29 @@ impl DefCollector<'_> {
                        BuiltinShadowMode::Module,
                    );
                    resolved_res.resolved_def.take_macros()
-                })
+                },
-            {
+                &mut |_err| (),
-                resolved.push((directive.module_id, call_id, directive.depth));
+            ) {
-                res = ReachedFixedPoint::No;
+                Ok(Ok(call_id)) => {
-                return false;
+                    resolved.push((directive.module_id, call_id, directive.depth));
+                    res = ReachedFixedPoint::No;
+                    return false;
+                }
+                Err(UnresolvedMacro) | Ok(Err(_)) => {}
            }
            true
        });
        attribute_macros.retain(|directive| {
-            if let Some(call_id) =
+            match item_attr_as_call_id(&directive.ast_id, self.db, self.def_map.krate, |path| {
-                directive.ast_id.as_call_id(self.db, self.def_map.krate, |path| {
+                self.resolve_attribute_macro(&directive, &path)
-                    self.resolve_attribute_macro(&directive, &path)
+            }) {
-                })
+                Ok(call_id) => {
-            {
+                    resolved.push((directive.module_id, call_id, 0));
-                resolved.push((directive.module_id, call_id, 0));
+                    res = ReachedFixedPoint::No;
-                res = ReachedFixedPoint::No;
+                    return false;
-                return false;
+                }
+                Err(UnresolvedMacro) => (),
            }
            true
@@ -902,7 +912,8 @@ impl DefCollector<'_> {
        for directive in &self.unexpanded_macros {
            let mut error = None;
-            directive.ast_id.as_call_id_with_errors(
+            match macro_call_as_call_id(
+                &directive.ast_id,
                self.db,
                self.def_map.krate,
                |path| {
@@ -918,15 +929,15 @@ impl DefCollector<'_> {
                &mut |e| {
                    error.get_or_insert(e);
                },
-            );
+            ) {
+                Ok(_) => (),
-            if let Some(err) = error {
+                Err(UnresolvedMacro) => {
-                self.def_map.diagnostics.push(DefDiagnostic::macro_error(
+                    self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call(
-                    directive.module_id,
+                        directive.module_id,
-                    MacroCallKind::FnLike(directive.ast_id.ast_id),
+                        directive.ast_id.ast_id,
-                    err.to_string(),
+                    ));
-                ));
+                }
-            }
+            };
        }
        // Emit diagnostics for all remaining unresolved imports.
@@ -1446,8 +1457,11 @@ impl ModCollector<'_, '_> {
        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
        // Case 1: try to resolve in legacy scope and expand macro_rules
-        if let Some(macro_call_id) =
+        if let Ok(Ok(macro_call_id)) = macro_call_as_call_id(
-            ast_id.as_call_id(self.def_collector.db, self.def_collector.def_map.krate, |path| {
+            &ast_id,
+            self.def_collector.db,
+            self.def_collector.def_map.krate,
+            |path| {
                path.as_ident().and_then(|name| {
                    self.def_collector.def_map.with_ancestor_maps(
                        self.def_collector.db,
@@ -1455,8 +1469,9 @@ impl ModCollector<'_, '_> {
                        &mut |map, module| map[module].scope.get_legacy_macro(&name),
                    )
                })
-            })
+            },
-        {
+            &mut |_err| (),
+        ) {
            self.def_collector.unexpanded_macros.push(MacroDirective {
                module_id: self.module_id,
                ast_id,
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index fdcdc23ae..dd1db0094 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -77,7 +77,7 @@ impl DefMap {
        original_module: LocalModuleId,
        visibility: &RawVisibility,
    ) -> Option<Visibility> {
-        match visibility {
+        let mut vis = match visibility {
            RawVisibility::Module(path) => {
                let (result, remaining) =
                    self.resolve_path(db, original_module, &path, BuiltinShadowMode::Module);
@@ -86,15 +86,28 @@ impl DefMap {
                }
                let types = result.take_types()?;
                match types {
-                    ModuleDefId::ModuleId(m) => Some(Visibility::Module(m)),
+                    ModuleDefId::ModuleId(m) => Visibility::Module(m),
                    _ => {
                        // error: visibility needs to refer to module
-                        None
+                        return None;
                    }
                }
            }
-            RawVisibility::Public => Some(Visibility::Public),
+            RawVisibility::Public => Visibility::Public,
+        };
+        // In block expressions, `self` normally refers to the containing non-block module, and
+        // `super` to its parent (etc.). However, visibilities must only refer to a module in the
+        // DefMap they're written in, so we restrict them when that happens.
+        if let Visibility::Module(m) = vis {
+            if self.block_id() != m.block {
+                mark::hit!(adjust_vis_in_block_def_map);
+                vis = Visibility::Module(self.module_id(self.root()));
+                log::debug!("visibility {:?} points outside DefMap, adjusting to {:?}", m, vis);
+            }
        }
+        Some(vis)
    }
    // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 57bc6fbd7..eb57ea7d6 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -6,7 +6,7 @@ use crate::{
 use base_db::{AnchoredPath, FileId};
 use either::Either;
-use mbe::{parse_to_token_tree, ExpandResult};
+use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
 use parser::FragmentKind;
 use syntax::ast::{self, AstToken};
@@ -182,25 +182,10 @@ fn assert_expand(
    // ```,
    // which is wrong but useful.
-    let mut args = Vec::new();
+    let args = parse_exprs_with_sep(tt, ',');
-    let mut current = Vec::new();
-    for tt in tt.token_trees.iter().cloned() {
-        match tt {
-            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
-                args.push(current);
-                current = Vec::new();
-            }
-            _ => {
-                current.push(tt);
-            }
-        }
-    }
-    if !current.is_empty() {
-        args.push(current);
-    }
    let arg_tts = args.into_iter().flat_map(|arg| {
-        quote! { &(##arg), }
+        quote! { &(#arg), }
    }.token_trees).collect::<Vec<_>>();
    let expanded = quote! {
@@ -238,35 +223,21 @@ fn format_args_expand(
    // ])
    // ```,
    // which is still not really correct, but close enough for now
-    let mut args = Vec::new();
+    let mut args = parse_exprs_with_sep(tt, ',');
-    let mut current = Vec::new();
-    for tt in tt.token_trees.iter().cloned() {
-        match tt {
-            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
-                args.push(current);
-                current = Vec::new();
-            }
-            _ => {
-                current.push(tt);
-            }
-        }
-    }
-    if !current.is_empty() {
-        args.push(current);
-    }
    if args.is_empty() {
        return ExpandResult::only_err(mbe::ExpandError::NoMatchingRule);
    }
    for arg in &mut args {
        // Remove `key =`.
-        if matches!(arg.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=' && p.spacing != tt::Spacing::Joint)
+        if matches!(arg.token_trees.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=' && p.spacing != tt::Spacing::Joint)
        {
-            arg.drain(..2);
+            arg.token_trees.drain(..2);
        }
    }
    let _format_string = args.remove(0);
    let arg_tts = args.into_iter().flat_map(|arg| {
-        quote! { std::fmt::ArgumentV1::new(&(##arg), std::fmt::Display::fmt), }
+        quote! { std::fmt::ArgumentV1::new(&(#arg), std::fmt::Display::fmt), }
    }.token_trees).collect::<Vec<_>>();
    let expanded = quote! {
        std::fmt::Arguments::new_v1(&[], &[##arg_tts])
@@ -720,6 +691,25 @@ mod tests {
    }
    #[test]
+    fn test_format_args_expand_with_comma_exprs() {
+        let expanded = expand_builtin_macro(
+            r#"
+            #[rustc_builtin_macro]
+            macro_rules! format_args {
+                ($fmt:expr) => ({ /* compiler built-in */ });
+                ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
+            }
+            format_args!("{} {:?}", a::<A,B>(), b);
+            "#,
+        );
+        assert_eq!(
+            expanded,
+            r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])"#
+        );
+    }
+    #[test]
    fn test_include_bytes_expand() {
        let expanded = expand_builtin_macro(
            r#"
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index c7609e90d..c94fb580a 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -189,6 +189,7 @@ pub mod known {
        // Components of known path (function name)
        filter_map,
        next,
+        iter_mut,
        // Builtin macros
        file,
        column,
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..f3a4333cb 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -3,8 +3,9 @@
 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 hir_def::{
@@ -234,36 +235,62 @@ 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);
+        }
+        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.ctor {
+        match self {
-            TypeCtor::Bool => write!(f, "bool")?,
+            Ty::Never => write!(f, "!")?,
-            TypeCtor::Char => write!(f, "char")?,
+            Ty::Str => write!(f, "str")?,
-            TypeCtor::Int(t) => write!(f, "{}", t)?,
+            Ty::Scalar(Scalar::Bool) => write!(f, "bool")?,
-            TypeCtor::Float(t) => write!(f, "{}", t)?,
+            Ty::Scalar(Scalar::Char) => write!(f, "char")?,
-            TypeCtor::Str => write!(f, "str")?,
+            &Ty::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?,
-            TypeCtor::Slice => {
+            &Ty::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
-                let t = self.parameters.as_single();
+            &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())?;
                } else {
                    write!(f, "&{}", m.as_keyword_for_ref())?;
@@ -274,10 +301,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 +331,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 +358,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 +366,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 +385,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 +398,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 +410,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 +429,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 +449,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 +519,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 +537,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 +566,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..18a4f5e8a 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -36,25 +36,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;
@@ -405,7 +395,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 +654,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..c33d8c61e 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 chalk_ir::TyVariableKind;
 use hir_def::{lang_item::LangItemTarget, type_ref::Mutability};
 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::Shared, ..))
-            (ty_app!(c1@TypeCtor::RawPtr(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
+            | (Ty::Ref(m1, ..), Ty::Ref(m2 @ Mutability::Shared, ..)) => {
-            | (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::Shared, ..))
+            | (Ty::Ref(Mutability::Mut, substs), &Ty::Raw(m2, ..)) => {
+                from_ty = Ty::Raw(m2, substs.clone());
            }
-            // Illegal mutablity conversion
+            // Illegal mutability conversion
-            (
+            (Ty::Raw(Mutability::Shared, ..), Ty::Raw(Mutability::Mut, ..))
-                ty_app!(TypeCtor::RawPtr(Mutability::Shared)),
+            | (Ty::Ref(Mutability::Shared, ..), 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..7852b3d23 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::TyVariableKind;
 use hir_def::{
-    builtin_type::Signedness,
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
    resolver::resolver_for_expr,
@@ -16,10 +16,11 @@ use test_utils::mark;
 use crate::{
    autoderef, 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, Mutability, Obligation, OpaqueTyId, Rawness, Scalar,
-    Rawness, Substs, TraitRef, Ty, TypeCtor,
+    Substs, TraitRef, Ty,
 };
 use super::{
@@ -82,10 +83,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 +118,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 +173,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 +191,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 +201,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 +248,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 +304,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 +316,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 +334,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 +359,7 @@ impl<'a> InferenceContext<'a> {
                        expr: tgt_expr,
                    });
                }
+                Ty::Never
-                Ty::simple(TypeCtor::Never)
            }
            Expr::Return { expr } => {
                if let Some(expr) = expr {
@@ -374,14 +368,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 +385,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 +424,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);
@@ -491,19 +478,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 +525,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 +538,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 +552,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 +583,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 +641,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 +654,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 +675,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::Shared, 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::Shared, 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 +762,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 +819,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 +896,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..a318e47f3 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -13,7 +13,7 @@ use hir_expand::name::Name;
 use test_utils::mark;
 use super::{BindingMode, Expectation, InferenceContext};
-use crate::{utils::variant_data, Substs, Ty, TypeCtor};
+use crate::{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 {
@@ -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() {
@@ -165,7 +162,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 +195,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 +204,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 +236,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>,
+}