6 files changed, 306 insertions, 112 deletions

diff --git a/crates/ra_hir/src/ty/display.rs b/crates/ra_hir/src/ty/display.rs
new file mode 100644
index 000000000..63ec9d7e1
--- /dev/null
+++ b/crates/ra_hir/src/ty/display.rs
@@ -0,0 +1,56 @@
+use std::fmt;
+
+use crate::db::HirDatabase;
+
+pub struct HirFormatter<'a, 'b, DB> {
+    pub db: &'a DB,
+    fmt: &'a mut fmt::Formatter<'b>,
+}
+
+pub trait HirDisplay {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result;
+    fn display<'a, DB>(&'a self, db: &'a DB) -> HirDisplayWrapper<'a, DB, Self>
+    where
+        Self: Sized,
+    {
+        HirDisplayWrapper(db, self)
+    }
+}
+
+impl<'a, 'b, DB> HirFormatter<'a, 'b, DB>
+where
+    DB: HirDatabase,
+{
+    pub fn write_joined<T: HirDisplay>(
+        &mut self,
+        iter: impl IntoIterator<Item = T>,
+        sep: &str,
+    ) -> fmt::Result {
+        let mut first = true;
+        for e in iter {
+            if !first {
+                write!(self, "{}", sep)?;
+            }
+            first = false;
+            e.hir_fmt(self)?;
+        }
+        Ok(())
+    }
+
+    /// This allows using the `write!` macro directly with a `HirFormatter`.
+    pub fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+        fmt::write(self.fmt, args)
+    }
+}
+
+pub struct HirDisplayWrapper<'a, DB, T>(&'a DB, &'a T);
+
+impl<'a, DB, T> fmt::Display for HirDisplayWrapper<'a, DB, T>
+where
+    DB: HirDatabase,
+    T: HirDisplay,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.1.hir_fmt(&mut HirFormatter { db: self.0, fmt: f })
+    }
+}
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 268d2c110..735cdecb9 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -63,6 +63,30 @@ enum ExprOrPatId {
 
 impl_froms!(ExprOrPatId: ExprId, PatId);
 
+/// Binding modes inferred for patterns.
+/// https://doc.rust-lang.org/reference/patterns.html#binding-modes
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+enum BindingMode {
+    Move,
+    Ref(Mutability),
+}
+
+impl BindingMode {
+    pub fn convert(annotation: &BindingAnnotation) -> BindingMode {
+        match annotation {
+            BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move,
+            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Shared),
+            BindingAnnotation::RefMut => BindingMode::Ref(Mutability::Mut),
+        }
+    }
+}
+
+impl Default for BindingMode {
+    fn default() -> Self {
+        BindingMode::Move
+    }
+}
+
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct InferenceResult {
@@ -530,6 +554,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         path: Option<&Path>,
         subpats: &[PatId],
         expected: &Ty,
+        default_bm: BindingMode,
     ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
 
@@ -542,13 +567,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 .and_then(|d| d.field(self.db, &Name::tuple_field_name(i)))
                 .map_or(Ty::Unknown, |field| field.ty(self.db))
                 .subst(&substs);
-            self.infer_pat(subpat, &expected_ty);
+            self.infer_pat(subpat, &expected_ty, default_bm);
         }
 
         ty
     }
 
-    fn infer_struct_pat(&mut self, path: Option<&Path>, subpats: &[FieldPat], expected: &Ty) -> Ty {
+    fn infer_struct_pat(
+        &mut self,
+        path: Option<&Path>,
+        subpats: &[FieldPat],
+        expected: &Ty,
+        default_bm: BindingMode,
+    ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
 
         self.unify(&ty, expected);
@@ -559,15 +590,45 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
             let expected_ty =
                 matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
-            self.infer_pat(subpat.pat, &expected_ty);
+            self.infer_pat(subpat.pat, &expected_ty, default_bm);
         }
 
         ty
     }
 
-    fn infer_pat(&mut self, pat: PatId, expected: &Ty) -> Ty {
+    fn infer_pat(&mut self, pat: PatId, mut expected: &Ty, mut default_bm: BindingMode) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
 
+        let is_non_ref_pat = match &body[pat] {
+            Pat::Tuple(..)
+            | Pat::TupleStruct { .. }
+            | Pat::Struct { .. }
+            | Pat::Range { .. }
+            | Pat::Slice { .. } => true,
+            // TODO: Path/Lit might actually evaluate to ref, but inference is unimplemented.
+            Pat::Path(..) | Pat::Lit(..) => true,
+            Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
+        };
+        if is_non_ref_pat {
+            while let Ty::Ref(inner, mutability) = expected {
+                expected = inner;
+                default_bm = match default_bm {
+                    BindingMode::Move => BindingMode::Ref(*mutability),
+                    BindingMode::Ref(Mutability::Shared) => BindingMode::Ref(Mutability::Shared),
+                    BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(*mutability),
+                }
+            }
+        } else if let Pat::Ref { .. } = &body[pat] {
+            tested_by!(match_ergonomics_ref);
+            // When you encounter a `&pat` pattern, reset to Move.
+            // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
+            default_bm = BindingMode::Move;
+        }
+
+        // Lose mutability.
+        let default_bm = default_bm;
+        let expected = expected;
+
         let ty = match &body[pat] {
             Pat::Tuple(ref args) => {
                 let expectations = match *expected {
@@ -579,7 +640,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let inner_tys = args
                     .iter()
                     .zip(expectations_iter)
-                    .map(|(&pat, ty)| self.infer_pat(pat, ty))
+                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
                     .collect::<Vec<_>>()
                     .into();
 
@@ -595,14 +656,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     }
                     _ => &Ty::Unknown,
                 };
-                let subty = self.infer_pat(*pat, expectation);
+                let subty = self.infer_pat(*pat, expectation, default_bm);
                 Ty::Ref(subty.into(), *mutability)
             }
             Pat::TupleStruct { path: ref p, args: ref subpats } => {
-                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected)
+                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
             }
             Pat::Struct { path: ref p, args: ref fields } => {
-                self.infer_struct_pat(p.as_ref(), fields, expected)
+                self.infer_struct_pat(p.as_ref(), fields, expected, default_bm)
             }
             Pat::Path(path) => {
                 // TODO use correct resolver for the surrounding expression
@@ -610,17 +671,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.infer_path_expr(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
             }
             Pat::Bind { mode, name: _name, subpat } => {
+                let mode = if mode == &BindingAnnotation::Unannotated {
+                    default_bm
+                } else {
+                    BindingMode::convert(mode)
+                };
                 let inner_ty = if let Some(subpat) = subpat {
-                    self.infer_pat(*subpat, expected)
+                    self.infer_pat(*subpat, expected, default_bm)
                 } else {
                     expected.clone()
                 };
                 let inner_ty = self.insert_type_vars_shallow(inner_ty);
 
                 let bound_ty = match mode {
-                    BindingAnnotation::Ref => Ty::Ref(inner_ty.clone().into(), Mutability::Shared),
-                    BindingAnnotation::RefMut => Ty::Ref(inner_ty.clone().into(), Mutability::Mut),
-                    BindingAnnotation::Mutable | BindingAnnotation::Unannotated => inner_ty.clone(),
+                    BindingMode::Ref(mutability) => Ty::Ref(inner_ty.clone().into(), mutability),
+                    BindingMode::Move => inner_ty.clone(),
                 };
                 let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty);
                 self.write_pat_ty(pat, bound_ty);
@@ -700,7 +765,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             Expr::For { iterable, body, pat } => {
                 let _iterable_ty = self.infer_expr(*iterable, &Expectation::none());
-                self.infer_pat(*pat, &Ty::Unknown);
+                self.infer_pat(*pat, &Ty::Unknown, BindingMode::default());
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 Ty::unit()
             }
@@ -714,7 +779,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     } else {
                         Ty::Unknown
                     };
-                    self.infer_pat(*arg_pat, &expected);
+                    self.infer_pat(*arg_pat, &expected, BindingMode::default());
                 }
 
                 // TODO: infer lambda type etc.
@@ -724,11 +789,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::Call { callee, args } => {
                 let callee_ty = self.infer_expr(*callee, &Expectation::none());
                 let (param_tys, ret_ty) = match &callee_ty {
-                    Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()),
-                    Ty::FnDef { substs, sig, .. } => {
-                        let ret_ty = sig.output.clone().subst(&substs);
+                    Ty::FnPtr(sig) => (sig.params().to_vec(), sig.ret().clone()),
+                    Ty::FnDef { substs, def, .. } => {
+                        let sig = self.db.callable_item_signature(*def);
+                        let ret_ty = sig.ret().clone().subst(&substs);
                         let param_tys =
-                            sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect();
+                            sig.params().iter().map(|ty| ty.clone().subst(&substs)).collect();
                         (param_tys, ret_ty)
                     }
                     _ => {
@@ -762,19 +828,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let method_ty = self.insert_type_vars(method_ty);
                 let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {
                     Ty::FnPtr(sig) => {
-                        if !sig.input.is_empty() {
-                            (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone())
+                        if !sig.params().is_empty() {
+                            (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
                         } else {
-                            (Ty::Unknown, Vec::new(), sig.output.clone())
+                            (Ty::Unknown, Vec::new(), sig.ret().clone())
                         }
                     }
-                    Ty::FnDef { substs, sig, .. } => {
-                        let ret_ty = sig.output.clone().subst(&substs);
-
-                        if !sig.input.is_empty() {
-                            let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs));
-                            let receiver_ty = arg_iter.next().unwrap();
-                            (receiver_ty, arg_iter.collect(), ret_ty)
+                    Ty::FnDef { substs, def, .. } => {
+                        let sig = self.db.callable_item_signature(*def);
+                        let ret_ty = sig.ret().clone().subst(&substs);
+
+                        if !sig.params().is_empty() {
+                            let mut params_iter =
+                                sig.params().iter().map(|ty| ty.clone().subst(&substs));
+                            let receiver_ty = params_iter.next().unwrap();
+                            (receiver_ty, params_iter.collect(), ret_ty)
                         } else {
                             (Ty::Unknown, Vec::new(), ret_ty)
                         }
@@ -804,7 +872,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 for arm in arms {
                     for &pat in &arm.pats {
-                        let _pat_ty = self.infer_pat(pat, &input_ty);
+                        let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
                     }
                     if let Some(guard_expr) = arm.guard {
                         self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool));
@@ -1004,7 +1072,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         decl_ty
                     };
 
-                    self.infer_pat(*pat, &ty);
+                    self.infer_pat(*pat, &ty, BindingMode::default());
                 }
                 Statement::Expr(expr) => {
                     self.infer_expr(*expr, &Expectation::none());
@@ -1020,7 +1088,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         for (type_ref, pat) in signature.params().iter().zip(body.params()) {
             let ty = self.make_ty(type_ref);
 
-            self.infer_pat(*pat, &ty);
+            self.infer_pat(*pat, &ty, BindingMode::default());
         }
         self.return_ty = self.make_ty(signature.ret_type());
     }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index f4e055feb..278f592d3 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -9,7 +9,7 @@
 use std::sync::Arc;
 
 use crate::{
-    Function, Struct, StructField, Enum, EnumVariant, Path, Name,
+    Function, Struct, StructField, Enum, EnumVariant, Path,
     ModuleDef, TypeAlias,
     Const, Static,
     HirDatabase,
@@ -51,12 +51,10 @@ impl Ty {
             }
             TypeRef::Placeholder => Ty::Unknown,
             TypeRef::Fn(params) => {
-                let mut inner_tys =
+                let inner_tys =
                     params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
-                let return_ty =
-                    inner_tys.pop().expect("TypeRef::Fn should always have at least return type");
-                let sig = FnSig { input: inner_tys, output: return_ty };
-                Ty::FnPtr(Arc::new(sig))
+                let sig = FnSig { params_and_return: inner_tys.into() };
+                Ty::FnPtr(sig)
             }
             TypeRef::Error => Ty::Unknown,
         }
@@ -214,6 +212,15 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
     }
 }
 
+/// Build the signature of a callable item (function, struct or enum variant).
+pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
+    match def {
+        CallableDef::Function(f) => fn_sig_for_fn(db, f),
+        CallableDef::Struct(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDef::EnumVariant(e) => fn_sig_for_enum_variant_constructor(db, e),
+    }
+}
+
 /// Build the type of a specific field of a struct or enum variant.
 pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
     let parent_def = field.parent_def(db);
@@ -226,19 +233,21 @@ pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
     Ty::from_hir(db, &resolver, type_ref)
 }
 
+fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
+    let signature = def.signature(db);
+    let resolver = def.resolver(db);
+    let params =
+        signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
+    let ret = Ty::from_hir(db, &resolver, signature.ret_type());
+    FnSig::from_params_and_return(params, ret)
+}
+
 /// Build the declared type of a function. This should not need to look at the
 /// function body.
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
-    let signature = def.signature(db);
-    let resolver = def.resolver(db);
     let generics = def.generic_params(db);
-    let name = def.name(db);
-    let input =
-        signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
-    let output = Ty::from_hir(db, &resolver, signature.ret_type());
-    let sig = Arc::new(FnSig { input, output });
     let substs = make_substs(&generics);
-    Ty::FnDef { def: def.into(), sig, name, substs }
+    Ty::FnDef { def: def.into(), substs }
 }
 
 /// Build the declared type of a const.
@@ -257,44 +266,58 @@ fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty {
     Ty::from_hir(db, &resolver, signature.type_ref())
 }
 
-/// Build the type of a tuple struct constructor.
-fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
+fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
     let var_data = def.variant_data(db);
     let fields = match var_data.fields() {
         Some(fields) => fields,
-        None => return type_for_struct(db, def), // Unit struct
+        None => panic!("fn_sig_for_struct_constructor called on unit struct"),
     };
     let resolver = def.resolver(db);
-    let generics = def.generic_params(db);
-    let name = def.name(db).unwrap_or_else(Name::missing);
-    let input = fields
+    let params = fields
         .iter()
         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
         .collect::<Vec<_>>();
-    let output = type_for_struct(db, def);
-    let sig = Arc::new(FnSig { input, output });
+    let ret = type_for_struct(db, def);
+    FnSig::from_params_and_return(params, ret)
+}
+
+/// Build the type of a tuple struct constructor.
+fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
+    let var_data = def.variant_data(db);
+    if var_data.fields().is_none() {
+        return type_for_struct(db, def); // Unit struct
+    }
+    let generics = def.generic_params(db);
     let substs = make_substs(&generics);
-    Ty::FnDef { def: def.into(), sig, name, substs }
+    Ty::FnDef { def: def.into(), substs }
 }
 
-/// Build the type of a tuple enum variant constructor.
-fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
+fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
     let var_data = def.variant_data(db);
     let fields = match var_data.fields() {
         Some(fields) => fields,
-        None => return type_for_enum(db, def.parent_enum(db)), // Unit variant
+        None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"),
     };
     let resolver = def.parent_enum(db).resolver(db);
-    let generics = def.parent_enum(db).generic_params(db);
-    let name = def.name(db).unwrap_or_else(Name::missing);
-    let input = fields
+    let params = fields
         .iter()
         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
         .collect::<Vec<_>>();
+    let generics = def.parent_enum(db).generic_params(db);
+    let substs = make_substs(&generics);
+    let ret = type_for_enum(db, def.parent_enum(db)).subst(&substs);
+    FnSig::from_params_and_return(params, ret)
+}
+
+/// Build the type of a tuple enum variant constructor.
+fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
+    let var_data = def.variant_data(db);
+    if var_data.fields().is_none() {
+        return type_for_enum(db, def.parent_enum(db)); // Unit variant
+    }
+    let generics = def.parent_enum(db).generic_params(db);
     let substs = make_substs(&generics);
-    let output = type_for_enum(db, def.parent_enum(db)).subst(&substs);
-    let sig = Arc::new(FnSig { input, output });
-    Ty::FnDef { def: def.into(), sig, name, substs }
+    Ty::FnDef { def: def.into(), substs }
 }
 
 fn make_substs(generics: &GenericParams) -> Substs {
@@ -310,20 +333,12 @@ fn make_substs(generics: &GenericParams) -> Substs {
 
 fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
     let generics = s.generic_params(db);
-    Ty::Adt {
-        def_id: s.into(),
-        name: s.name(db).unwrap_or_else(Name::missing),
-        substs: make_substs(&generics),
-    }
+    Ty::Adt { def_id: s.into(), substs: make_substs(&generics) }
 }
 
 fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
     let generics = s.generic_params(db);
-    Ty::Adt {
-        def_id: s.into(),
-        name: s.name(db).unwrap_or_else(Name::missing),
-        substs: make_substs(&generics),
-    }
+    Ty::Adt { def_id: s.into(), substs: make_substs(&generics) }
 }
 
 fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 94b757af2..804824868 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -7,10 +7,12 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 
 use crate::{
-    HirDatabase, module_tree::ModuleId, Module, Crate, Name, Function, Trait,
+    HirDatabase, Module, Crate, Name, Function, Trait,
     ids::TraitId,
     impl_block::{ImplId, ImplBlock, ImplItem},
     ty::{AdtDef, Ty},
+    nameres::CrateModuleId,
+
 };
 
 /// This is used as a key for indexing impls.
@@ -33,10 +35,10 @@ impl TyFingerprint {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplBlocks {
-    /// To make sense of the ModuleIds, we need the source root.
+    /// To make sense of the CrateModuleIds, we need the source root.
     krate: Crate,
-    impls: FxHashMap<TyFingerprint, Vec<(ModuleId, ImplId)>>,
-    impls_by_trait: FxHashMap<TraitId, Vec<(ModuleId, ImplId)>>,
+    impls: FxHashMap<TyFingerprint, Vec<(CrateModuleId, ImplId)>>,
+    impls_by_trait: FxHashMap<TraitId, Vec<(CrateModuleId, ImplId)>>,
 }
 
 impl CrateImplBlocks {
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index 5741ca90d..30aeac48e 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -10,14 +10,6 @@ pub enum UncertainIntTy {
 }
 
 impl UncertainIntTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
-            UncertainIntTy::Unknown => "{integer}",
-            UncertainIntTy::Signed(ty) => ty.ty_to_string(),
-            UncertainIntTy::Unsigned(ty) => ty.ty_to_string(),
-        }
-    }
-
     pub fn from_name(name: &Name) -> Option<UncertainIntTy> {
         if let Some(ty) = IntTy::from_name(name) {
             Some(UncertainIntTy::Signed(ty))
@@ -29,6 +21,16 @@ impl UncertainIntTy {
     }
 }
 
+impl fmt::Display for UncertainIntTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            UncertainIntTy::Unknown => write!(f, "{{integer}}"),
+            UncertainIntTy::Signed(ty) => write!(f, "{}", ty),
+            UncertainIntTy::Unsigned(ty) => write!(f, "{}", ty),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Copy)]
 pub enum UncertainFloatTy {
     Unknown,
@@ -36,13 +38,6 @@ pub enum UncertainFloatTy {
 }
 
 impl UncertainFloatTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
-            UncertainFloatTy::Unknown => "{float}",
-            UncertainFloatTy::Known(ty) => ty.ty_to_string(),
-        }
-    }
-
     pub fn from_name(name: &Name) -> Option<UncertainFloatTy> {
         if let Some(ty) = FloatTy::from_name(name) {
             Some(UncertainFloatTy::Known(ty))
@@ -52,6 +47,15 @@ impl UncertainFloatTy {
     }
 }
 
+impl fmt::Display for UncertainFloatTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            UncertainFloatTy::Unknown => write!(f, "{{float}}"),
+            UncertainFloatTy::Known(ty) => write!(f, "{}", ty),
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
 pub enum IntTy {
     Isize,
@@ -70,22 +74,19 @@ impl fmt::Debug for IntTy {
 
 impl fmt::Display for IntTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
-
-impl IntTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
+        let s = match *self {
             IntTy::Isize => "isize",
             IntTy::I8 => "i8",
             IntTy::I16 => "i16",
             IntTy::I32 => "i32",
             IntTy::I64 => "i64",
             IntTy::I128 => "i128",
-        }
+        };
+        write!(f, "{}", s)
     }
+}
 
+impl IntTy {
     pub fn from_name(name: &Name) -> Option<IntTy> {
         match name.as_known_name()? {
             KnownName::Isize => Some(IntTy::Isize),
@@ -109,18 +110,21 @@ pub enum UintTy {
     U128,
 }
 
-impl UintTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
+impl fmt::Display for UintTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let s = match *self {
             UintTy::Usize => "usize",
             UintTy::U8 => "u8",
             UintTy::U16 => "u16",
             UintTy::U32 => "u32",
             UintTy::U64 => "u64",
             UintTy::U128 => "u128",
-        }
+        };
+        write!(f, "{}", s)
     }
+}
 
+impl UintTy {
     pub fn from_name(name: &Name) -> Option<UintTy> {
         match name.as_known_name()? {
             KnownName::Usize => Some(UintTy::Usize),
@@ -140,12 +144,6 @@ impl fmt::Debug for UintTy {
     }
 }
 
-impl fmt::Display for UintTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
-
 #[derive(Clone, PartialEq, Eq, Hash, Copy, PartialOrd, Ord)]
 pub enum FloatTy {
     F32,
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index c7d409e6d..0f2172ddf 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -10,6 +10,7 @@ use test_utils::covers;
 use crate::{
     source_binder,
     mock::MockDatabase,
+    ty::display::HirDisplay,
 };
 
 // These tests compare the inference results for all expressions in a file
@@ -830,6 +831,60 @@ fn test(x: &i32) {
 }
 
 #[test]
+fn infer_pattern_match_ergonomics() {
+    assert_snapshot_matches!(
+        infer(r#"
+struct A<T>(T);
+
+fn test() {
+    let A(n) = &A(1);
+    let A(n) = &mut A(1);
+}
+"#),
+    @r###"
+[28; 79) '{     ...(1); }': ()
+[38; 42) 'A(n)': A<i32>
+[40; 41) 'n': &i32
+[45; 50) '&A(1)': &A<i32>
+[46; 47) 'A': A<i32>(T) -> A<T>
+[46; 50) 'A(1)': A<i32>
+[48; 49) '1': i32
+[60; 64) 'A(n)': A<i32>
+[62; 63) 'n': &mut i32
+[67; 76) '&mut A(1)': &mut A<i32>
+[72; 73) 'A': A<i32>(T) -> A<T>
+[72; 76) 'A(1)': A<i32>
+[74; 75) '1': i32"###
+    );
+}
+
+#[test]
+fn infer_pattern_match_ergonomics_ref() {
+    covers!(match_ergonomics_ref);
+    assert_snapshot_matches!(
+        infer(r#"
+fn test() {
+    let v = &(1, &2);
+    let (_, &w) = v;
+}
+"#),
+    @r###"
+[11; 57) '{     ...= v; }': ()
+[21; 22) 'v': &(i32, &i32)
+[25; 33) '&(1, &2)': &(i32, &i32)
+[26; 33) '(1, &2)': (i32, &i32)
+[27; 28) '1': i32
+[30; 32) '&2': &i32
+[31; 32) '2': i32
+[43; 50) '(_, &w)': (i32, &i32)
+[44; 45) '_': i32
+[47; 49) '&w': &i32
+[48; 49) 'w': i32
+[53; 54) 'v': &(i32, &i32)"###
+    );
+}
+
+#[test]
 fn infer_adt_pattern() {
     assert_snapshot_matches!(
         infer(r#"
@@ -2142,7 +2197,7 @@ fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
     let node = algo::find_node_at_offset::<ast::Expr>(syntax.syntax(), pos.offset).unwrap();
     let expr = body_source_map.node_expr(node).unwrap();
     let ty = &inference_result[expr];
-    ty.to_string()
+    ty.display(db).to_string()
 }
 
 fn infer(content: &str) -> String {
@@ -2178,7 +2233,7 @@ fn infer(content: &str) -> String {
                 "{} '{}': {}\n",
                 syntax_ptr.range(),
                 ellipsize(node.text().to_string().replace("\n", " "), 15),
-                ty
+                ty.display(&db)
             )
             .unwrap();
         }