1 files changed, 103 insertions, 70 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index bad811a56..2ea3b341f 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -9,16 +9,16 @@ pub(crate) mod method_resolution;
 mod op;
 mod lower;
 mod infer;
+pub(crate) mod display;
 
 use std::sync::Arc;
 use std::{fmt, mem};
 
-use join_to_string::join;
+use crate::{Name, AdtDef, type_ref::Mutability, db::HirDatabase};
 
-use crate::{Name, AdtDef, type_ref::Mutability};
-
-pub(crate) use lower::{TypableDef, CallableDef, type_for_def, type_for_field};
+pub(crate) use lower::{TypableDef, CallableDef, type_for_def, type_for_field, callable_item_sig};
 pub(crate) use infer::{infer, InferenceResult, InferTy};
+use display::{HirDisplay, HirFormatter};
 
 /// A type. This is based on the `TyKind` enum in rustc (librustc/ty/sty.rs).
 ///
@@ -42,8 +42,6 @@ pub enum Ty {
     Adt {
         /// The definition of the struct/enum.
         def_id: AdtDef,
-        /// The name, for displaying.
-        name: Name,
         /// Substitutions for the generic parameters of the type.
         substs: Substs,
     },
@@ -79,10 +77,6 @@ pub enum Ty {
     FnDef {
         /// The definition of the function / constructor.
         def: CallableDef,
-        /// For display
-        name: Name,
-        /// Parameters and return type
-        sig: Arc<FnSig>,
         /// Substitutions for the generic parameters of the type
         substs: Substs,
     },
@@ -95,7 +89,7 @@ pub enum Ty {
     /// fn foo() -> i32 { 1 }
     /// let bar: fn() -> i32 = foo;
     /// ```
-    FnPtr(Arc<FnSig>),
+    FnPtr(FnSig),
 
     /// The never type `!`.
     Never,
@@ -132,13 +126,44 @@ impl Substs {
     pub fn empty() -> Substs {
         Substs(Arc::new([]))
     }
+
+    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        // Without an Arc::make_mut_slice, we can't avoid the clone here:
+        let mut v: Vec<_> = self.0.iter().cloned().collect();
+        for t in &mut v {
+            t.walk_mut(f);
+        }
+        self.0 = v.into();
+    }
 }
 
 /// A function signature.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct FnSig {
-    input: Vec<Ty>,
-    output: Ty,
+    params_and_return: Arc<[Ty]>,
+}
+
+impl FnSig {
+    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty) -> FnSig {
+        params.push(ret);
+        FnSig { params_and_return: params.into() }
+    }
+    pub fn params(&self) -> &[Ty] {
+        &self.params_and_return[0..self.params_and_return.len() - 1]
+    }
+
+    pub fn ret(&self) -> &Ty {
+        &self.params_and_return[self.params_and_return.len() - 1]
+    }
+
+    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        // Without an Arc::make_mut_slice, we can't avoid the clone here:
+        let mut v: Vec<_> = self.params_and_return.iter().cloned().collect();
+        for t in &mut v {
+            t.walk_mut(f);
+        }
+        self.params_and_return = v.into();
+    }
 }
 
 impl Ty {
@@ -157,16 +182,12 @@ impl Ty {
                 }
             }
             Ty::FnPtr(sig) => {
-                for input in &sig.input {
+                for input in sig.params() {
                     input.walk(f);
                 }
-                sig.output.walk(f);
+                sig.ret().walk(f);
             }
-            Ty::FnDef { substs, sig, .. } => {
-                for input in &sig.input {
-                    input.walk(f);
-                }
-                sig.output.walk(f);
+            Ty::FnDef { substs, .. } => {
                 for t in substs.0.iter() {
                     t.walk(f);
                 }
@@ -203,32 +224,13 @@ impl Ty {
                 *ts = v.into();
             }
             Ty::FnPtr(sig) => {
-                let sig_mut = Arc::make_mut(sig);
-                for input in &mut sig_mut.input {
-                    input.walk_mut(f);
-                }
-                sig_mut.output.walk_mut(f);
+                sig.walk_mut(f);
             }
-            Ty::FnDef { substs, sig, .. } => {
-                let sig_mut = Arc::make_mut(sig);
-                for input in &mut sig_mut.input {
-                    input.walk_mut(f);
-                }
-                sig_mut.output.walk_mut(f);
-                // Without an Arc::make_mut_slice, we can't avoid the clone here:
-                let mut v: Vec<_> = substs.0.iter().cloned().collect();
-                for t in &mut v {
-                    t.walk_mut(f);
-                }
-                substs.0 = v.into();
+            Ty::FnDef { substs, .. } => {
+                substs.walk_mut(f);
             }
             Ty::Adt { substs, .. } => {
-                // Without an Arc::make_mut_slice, we can't avoid the clone here:
-                let mut v: Vec<_> = substs.0.iter().cloned().collect();
-                for t in &mut v {
-                    t.walk_mut(f);
-                }
-                substs.0 = v.into();
+                substs.walk_mut(f);
             }
             Ty::Bool
             | Ty::Char
@@ -265,8 +267,8 @@ impl Ty {
     /// `Option<u32>` afterwards.)
     pub fn apply_substs(self, substs: Substs) -> Ty {
         match self {
-            Ty::Adt { def_id, name, .. } => Ty::Adt { def_id, name, substs },
-            Ty::FnDef { def, name, sig, .. } => Ty::FnDef { def, name, sig, substs },
+            Ty::Adt { def_id, .. } => Ty::Adt { def_id, substs },
+            Ty::FnDef { def, .. } => Ty::FnDef { def, substs },
             _ => self,
         }
     }
@@ -297,50 +299,81 @@ impl Ty {
     }
 }
 
-impl fmt::Display for Ty {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl HirDisplay for &Ty {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
+        HirDisplay::hir_fmt(*self, f)
+    }
+}
+
+impl HirDisplay for Ty {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
         match self {
-            Ty::Bool => write!(f, "bool"),
-            Ty::Char => write!(f, "char"),
-            Ty::Int(t) => write!(f, "{}", t.ty_to_string()),
-            Ty::Float(t) => write!(f, "{}", t.ty_to_string()),
-            Ty::Str => write!(f, "str"),
-            Ty::Slice(t) | Ty::Array(t) => write!(f, "[{}]", t),
-            Ty::RawPtr(t, m) => write!(f, "*{}{}", m.as_keyword_for_ptr(), t),
-            Ty::Ref(t, m) => write!(f, "&{}{}", m.as_keyword_for_ref(), t),
-            Ty::Never => write!(f, "!"),
+            Ty::Bool => write!(f, "bool")?,
+            Ty::Char => write!(f, "char")?,
+            Ty::Int(t) => write!(f, "{}", t)?,
+            Ty::Float(t) => write!(f, "{}", t)?,
+            Ty::Str => write!(f, "str")?,
+            Ty::Slice(t) | Ty::Array(t) => {
+                write!(f, "[{}]", t.display(f.db))?;
+            }
+            Ty::RawPtr(t, m) => {
+                write!(f, "*{}{}", m.as_keyword_for_ptr(), t.display(f.db))?;
+            }
+            Ty::Ref(t, m) => {
+                write!(f, "&{}{}", m.as_keyword_for_ref(), t.display(f.db))?;
+            }
+            Ty::Never => write!(f, "!")?,
             Ty::Tuple(ts) => {
                 if ts.len() == 1 {
-                    write!(f, "({},)", ts[0])
+                    write!(f, "({},)", ts[0].display(f.db))?;
                 } else {
-                    join(ts.iter()).surround_with("(", ")").separator(", ").to_fmt(f)
+                    write!(f, "(")?;
+                    f.write_joined(&**ts, ", ")?;
+                    write!(f, ")")?;
                 }
             }
             Ty::FnPtr(sig) => {
-                join(sig.input.iter()).surround_with("fn(", ")").separator(", ").to_fmt(f)?;
-                write!(f, " -> {}", sig.output)
+                write!(f, "fn(")?;
+                f.write_joined(sig.params(), ", ")?;
+                write!(f, ") -> {}", sig.ret().display(f.db))?;
             }
-            Ty::FnDef { def, name, substs, sig, .. } => {
+            Ty::FnDef { def, substs, .. } => {
+                let sig = f.db.callable_item_signature(*def);
+                let name = match def {
+                    CallableDef::Function(ff) => ff.name(f.db),
+                    CallableDef::Struct(s) => s.name(f.db).unwrap_or_else(Name::missing),
+                    CallableDef::EnumVariant(e) => e.name(f.db).unwrap_or_else(Name::missing),
+                };
                 match def {
                     CallableDef::Function(_) => write!(f, "fn {}", name)?,
                     CallableDef::Struct(_) | CallableDef::EnumVariant(_) => write!(f, "{}", name)?,
                 }
                 if substs.0.len() > 0 {
-                    join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?;
+                    write!(f, "<")?;
+                    f.write_joined(&*substs.0, ", ")?;
+                    write!(f, ">")?;
                 }
-                join(sig.input.iter()).surround_with("(", ")").separator(", ").to_fmt(f)?;
-                write!(f, " -> {}", sig.output)
+                write!(f, "(")?;
+                f.write_joined(sig.params(), ", ")?;
+                write!(f, ") -> {}", sig.ret().display(f.db))?;
             }
-            Ty::Adt { name, substs, .. } => {
+            Ty::Adt { def_id, substs, .. } => {
+                let name = match def_id {
+                    AdtDef::Struct(s) => s.name(f.db),
+                    AdtDef::Enum(e) => e.name(f.db),
+                }
+                .unwrap_or_else(Name::missing);
                 write!(f, "{}", name)?;
                 if substs.0.len() > 0 {
-                    join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?;
+                    write!(f, "<")?;
+                    f.write_joined(&*substs.0, ", ")?;
+                    write!(f, ">")?;
                 }
-                Ok(())
             }
-            Ty::Param { name, .. } => write!(f, "{}", name),
-            Ty::Unknown => write!(f, "{{unknown}}"),
-            Ty::Infer(..) => write!(f, "_"),
+            Ty::Param { name, .. } => write!(f, "{}", name)?,
+            Ty::Unknown => write!(f, "{{unknown}}")?,
+            Ty::Infer(..) => write!(f, "_")?,
         }
+        Ok(())
     }
 }