TypeName => TypeCtor

6 files changed, 95 insertions, 95 deletions

diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 6219402d4..5926b5758 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -53,7 +53,7 @@ pub use self::{
     name::Name,
     ids::{HirFileId, MacroCallId, MacroCallLoc, HirInterner},
     nameres::{PerNs, Namespace},
-    ty::{Ty, ApplicationTy, TypeName, Substs, display::HirDisplay},
+    ty::{Ty, ApplicationTy, TypeCtor, Substs, display::HirDisplay},
     impl_block::{ImplBlock, ImplItem},
     docs::{Docs, Documentation},
     adt::AdtDef,
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 0bb716569..1d9e7b76c 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -21,7 +21,7 @@ pub(crate) use infer::{infer, InferenceResult, InferTy};
 use display::{HirDisplay, HirFormatter};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-pub enum TypeName {
+pub enum TypeCtor {
     /// The primitive boolean type. Written as `bool`.
     Bool,
 
@@ -87,7 +87,7 @@ pub enum TypeName {
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct ApplicationTy {
-    pub name: TypeName,
+    pub name: TypeCtor,
     pub parameters: Substs,
 }
 
@@ -191,17 +191,17 @@ impl FnSig {
 }
 
 impl Ty {
-    pub fn simple(name: TypeName) -> Ty {
+    pub fn simple(name: TypeCtor) -> Ty {
         Ty::Apply(ApplicationTy { name, parameters: Substs::empty() })
     }
-    pub fn apply_one(name: TypeName, param: Ty) -> Ty {
+    pub fn apply_one(name: TypeCtor, param: Ty) -> Ty {
         Ty::Apply(ApplicationTy { name, parameters: Substs::single(param) })
     }
-    pub fn apply(name: TypeName, parameters: Substs) -> Ty {
+    pub fn apply(name: TypeCtor, parameters: Substs) -> Ty {
         Ty::Apply(ApplicationTy { name, parameters })
     }
     pub fn unit() -> Self {
-        Ty::apply(TypeName::Tuple, Substs::empty())
+        Ty::apply(TypeCtor::Tuple, Substs::empty())
     }
 
     pub fn walk(&self, f: &mut impl FnMut(&Ty)) {
@@ -236,7 +236,7 @@ impl Ty {
 
     pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
         match self {
-            Ty::Apply(ApplicationTy { name: TypeName::Ref(mutability), parameters }) => {
+            Ty::Apply(ApplicationTy { name: TypeCtor::Ref(mutability), parameters }) => {
                 Some((parameters.as_single(), *mutability))
             }
             _ => None,
@@ -245,7 +245,7 @@ impl Ty {
 
     pub fn as_adt(&self) -> Option<(AdtDef, &Substs)> {
         match self {
-            Ty::Apply(ApplicationTy { name: TypeName::Adt(adt_def), parameters }) => {
+            Ty::Apply(ApplicationTy { name: TypeCtor::Adt(adt_def), parameters }) => {
                 Some((*adt_def, parameters))
             }
             _ => None,
@@ -254,7 +254,7 @@ impl Ty {
 
     pub fn as_tuple(&self) -> Option<&Substs> {
         match self {
-            Ty::Apply(ApplicationTy { name: TypeName::Tuple, parameters }) => Some(parameters),
+            Ty::Apply(ApplicationTy { name: TypeCtor::Tuple, parameters }) => Some(parameters),
             _ => None,
         }
     }
@@ -262,8 +262,8 @@ impl Ty {
     fn builtin_deref(&self) -> Option<Ty> {
         match self {
             Ty::Apply(a_ty) => match a_ty.name {
-                TypeName::Ref(..) => Some(Ty::clone(a_ty.parameters.as_single())),
-                TypeName::RawPtr(..) => Some(Ty::clone(a_ty.parameters.as_single())),
+                TypeCtor::Ref(..) => Some(Ty::clone(a_ty.parameters.as_single())),
+                TypeCtor::RawPtr(..) => Some(Ty::clone(a_ty.parameters.as_single())),
                 _ => None,
             },
             _ => None,
@@ -318,25 +318,25 @@ impl HirDisplay for &Ty {
 impl HirDisplay for ApplicationTy {
     fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
         match self.name {
-            TypeName::Bool => write!(f, "bool")?,
-            TypeName::Char => write!(f, "char")?,
-            TypeName::Int(t) => write!(f, "{}", t)?,
-            TypeName::Float(t) => write!(f, "{}", t)?,
-            TypeName::Str => write!(f, "str")?,
-            TypeName::Slice | TypeName::Array => {
+            TypeCtor::Bool => write!(f, "bool")?,
+            TypeCtor::Char => write!(f, "char")?,
+            TypeCtor::Int(t) => write!(f, "{}", t)?,
+            TypeCtor::Float(t) => write!(f, "{}", t)?,
+            TypeCtor::Str => write!(f, "str")?,
+            TypeCtor::Slice | TypeCtor::Array => {
                 let t = self.parameters.as_single();
                 write!(f, "[{}]", t.display(f.db))?;
             }
-            TypeName::RawPtr(m) => {
+            TypeCtor::RawPtr(m) => {
                 let t = self.parameters.as_single();
                 write!(f, "*{}{}", m.as_keyword_for_ptr(), t.display(f.db))?;
             }
-            TypeName::Ref(m) => {
+            TypeCtor::Ref(m) => {
                 let t = self.parameters.as_single();
                 write!(f, "&{}{}", m.as_keyword_for_ref(), t.display(f.db))?;
             }
-            TypeName::Never => write!(f, "!")?,
-            TypeName::Tuple => {
+            TypeCtor::Never => write!(f, "!")?,
+            TypeCtor::Tuple => {
                 let ts = &self.parameters;
                 if ts.0.len() == 1 {
                     write!(f, "({},)", ts.0[0].display(f.db))?;
@@ -346,13 +346,13 @@ impl HirDisplay for ApplicationTy {
                     write!(f, ")")?;
                 }
             }
-            TypeName::FnPtr => {
+            TypeCtor::FnPtr => {
                 let sig = FnSig::from_fn_ptr_substs(&self.parameters);
                 write!(f, "fn(")?;
                 f.write_joined(sig.params(), ", ")?;
                 write!(f, ") -> {}", sig.ret().display(f.db))?;
             }
-            TypeName::FnDef(def) => {
+            TypeCtor::FnDef(def) => {
                 let sig = f.db.callable_item_signature(def);
                 let name = match def {
                     CallableDef::Function(ff) => ff.name(f.db),
@@ -372,7 +372,7 @@ impl HirDisplay for ApplicationTy {
                 f.write_joined(sig.params(), ", ")?;
                 write!(f, ") -> {}", sig.ret().display(f.db))?;
             }
-            TypeName::Adt(def_id) => {
+            TypeCtor::Adt(def_id) => {
                 let name = match def_id {
                     AdtDef::Struct(s) => s.name(f.db),
                     AdtDef::Enum(e) => e.name(f.db),
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 0dafd8cbd..e975f9217 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -38,7 +38,7 @@ use crate::{
     resolve::{Resolver, Resolution},
     nameres::Namespace
 };
-use super::{Ty, TypableDef, Substs, primitive, op, FnSig, ApplicationTy, TypeName};
+use super::{Ty, TypableDef, Substs, primitive, op, FnSig, ApplicationTy, TypeCtor};
 
 /// The entry point of type inference.
 pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
@@ -278,11 +278,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         match ty {
             Ty::Unknown => self.new_type_var(),
             Ty::Apply(ApplicationTy {
-                name: TypeName::Int(primitive::UncertainIntTy::Unknown),
+                name: TypeCtor::Int(primitive::UncertainIntTy::Unknown),
                 ..
             }) => self.new_integer_var(),
             Ty::Apply(ApplicationTy {
-                name: TypeName::Float(primitive::UncertainFloatTy::Unknown),
+                name: TypeCtor::Float(primitive::UncertainFloatTy::Unknown),
                 ..
             }) => self.new_float_var(),
             _ => ty,
@@ -629,7 +629,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     .collect::<Vec<_>>()
                     .into();
 
-                Ty::apply(TypeName::Tuple, Substs(inner_tys))
+                Ty::apply(TypeCtor::Tuple, Substs(inner_tys))
             }
             Pat::Ref { pat, mutability } => {
                 let expectation = match expected.as_reference() {
@@ -642,7 +642,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     _ => &Ty::Unknown,
                 };
                 let subty = self.infer_pat(*pat, expectation, default_bm);
-                Ty::apply_one(TypeName::Ref(*mutability), subty.into())
+                Ty::apply_one(TypeCtor::Ref(*mutability), subty.into())
             }
             Pat::TupleStruct { path: ref p, args: ref subpats } => {
                 self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
@@ -670,7 +670,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 let bound_ty = match mode {
                     BindingMode::Ref(mutability) => {
-                        Ty::apply_one(TypeName::Ref(mutability), inner_ty.clone().into())
+                        Ty::apply_one(TypeCtor::Ref(mutability), inner_ty.clone().into())
                     }
                     BindingMode::Move => inner_ty.clone(),
                 };
@@ -725,7 +725,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             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(TypeName::Bool)));
+                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
                 let then_ty = self.infer_expr(*then_branch, expected);
                 match else_branch {
                     Some(else_branch) => {
@@ -742,11 +742,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::Loop { body } => {
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 // TODO handle break with value
-                Ty::simple(TypeName::Never)
+                Ty::simple(TypeCtor::Never)
             }
             Expr::While { condition, body } => {
                 // while let is desugared to a match loop, so this is always simple while
-                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeName::Bool)));
+                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
                 Ty::unit()
             }
@@ -777,11 +777,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let callee_ty = self.infer_expr(*callee, &Expectation::none());
                 let (param_tys, ret_ty) = match &callee_ty {
                     Ty::Apply(a_ty) => match a_ty.name {
-                        TypeName::FnPtr => {
+                        TypeCtor::FnPtr => {
                             let sig = FnSig::from_fn_ptr_substs(&a_ty.parameters);
                             (sig.params().to_vec(), sig.ret().clone())
                         }
-                        TypeName::FnDef(def) => {
+                        TypeCtor::FnDef(def) => {
                             let sig = self.db.callable_item_signature(def);
                             let ret_ty = sig.ret().clone().subst(&a_ty.parameters);
                             let param_tys = sig
@@ -824,7 +824,7 @@ 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::Apply(a_ty) => match a_ty.name {
-                        TypeName::FnPtr => {
+                        TypeCtor::FnPtr => {
                             let sig = FnSig::from_fn_ptr_substs(&a_ty.parameters);
                             if !sig.params().is_empty() {
                                 (
@@ -836,7 +836,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                                 (Ty::Unknown, Vec::new(), sig.ret().clone())
                             }
                         }
-                        TypeName::FnDef(def) => {
+                        TypeCtor::FnDef(def) => {
                             let sig = self.db.callable_item_signature(def);
                             let ret_ty = sig.ret().clone().subst(&a_ty.parameters);
 
@@ -858,7 +858,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 // Apply autoref so the below unification works correctly
                 let actual_receiver_ty = match expected_receiver_ty.as_reference() {
                     Some((_, mutability)) => {
-                        Ty::apply_one(TypeName::Ref(mutability), derefed_receiver_ty)
+                        Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty)
                     }
                     _ => derefed_receiver_ty,
                 };
@@ -885,7 +885,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     if let Some(guard_expr) = arm.guard {
                         self.infer_expr(
                             guard_expr,
-                            &Expectation::has_type(Ty::simple(TypeName::Bool)),
+                            &Expectation::has_type(Ty::simple(TypeCtor::Bool)),
                         );
                     }
                     self.infer_expr(arm.expr, &expected);
@@ -898,19 +898,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
                 self.infer_path_expr(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
             }
-            Expr::Continue => Ty::simple(TypeName::Never),
+            Expr::Continue => Ty::simple(TypeCtor::Never),
             Expr::Break { expr } => {
                 if let Some(expr) = expr {
                     // TODO handle break with value
                     self.infer_expr(*expr, &Expectation::none());
                 }
-                Ty::simple(TypeName::Never)
+                Ty::simple(TypeCtor::Never)
             }
             Expr::Return { expr } => {
                 if let Some(expr) = expr {
                     self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone()));
                 }
-                Ty::simple(TypeName::Never)
+                Ty::simple(TypeCtor::Never)
             }
             Expr::StructLit { path, fields, spread } => {
                 let (ty, def_id) = self.resolve_variant(path.as_ref());
@@ -933,11 +933,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     .autoderef(self.db)
                     .find_map(|derefed_ty| match derefed_ty {
                         Ty::Apply(a_ty) => match a_ty.name {
-                            TypeName::Tuple => {
+                            TypeCtor::Tuple => {
                                 let i = name.to_string().parse::<usize>().ok();
                                 i.and_then(|i| a_ty.parameters.0.get(i).cloned())
                             }
-                            TypeName::Adt(AdtDef::Struct(s)) => {
+                            TypeCtor::Adt(AdtDef::Struct(s)) => {
                                 s.field(self.db, name).map(|field| {
                                     self.write_field_resolution(tgt_expr, field);
                                     field.ty(self.db).subst(&a_ty.parameters)
@@ -973,7 +973,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     };
                 // TODO reference coercions etc.
                 let inner_ty = self.infer_expr(*expr, &expectation);
-                Ty::apply_one(TypeName::Ref(*mutability), inner_ty)
+                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
             }
             Expr::UnaryOp { expr, op } => {
                 let inner_ty = self.infer_expr(*expr, &Expectation::none());
@@ -989,9 +989,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     UnaryOp::Neg => {
                         match &inner_ty {
                             Ty::Apply(a_ty) => match a_ty.name {
-                                TypeName::Int(primitive::UncertainIntTy::Unknown)
-                                | TypeName::Int(primitive::UncertainIntTy::Signed(..))
-                                | TypeName::Float(..) => inner_ty,
+                                TypeCtor::Int(primitive::UncertainIntTy::Unknown)
+                                | TypeCtor::Int(primitive::UncertainIntTy::Signed(..))
+                                | TypeCtor::Float(..) => inner_ty,
                                 _ => Ty::Unknown,
                             },
                             Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => {
@@ -1004,7 +1004,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     UnaryOp::Not => {
                         match &inner_ty {
                             Ty::Apply(a_ty) => match a_ty.name {
-                                TypeName::Bool | TypeName::Int(_) => inner_ty,
+                                TypeCtor::Bool | TypeCtor::Int(_) => inner_ty,
                                 _ => Ty::Unknown,
                             },
                             Ty::Infer(InferTy::IntVar(..)) => inner_ty,
@@ -1018,7 +1018,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 Some(op) => {
                     let lhs_expectation = match op {
                         BinaryOp::BooleanAnd | BinaryOp::BooleanOr => {
-                            Expectation::has_type(Ty::simple(TypeName::Bool))
+                            Expectation::has_type(Ty::simple(TypeCtor::Bool))
                         }
                         _ => Expectation::none(),
                     };
@@ -1039,12 +1039,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     ty_vec.push(self.infer_expr(*arg, &Expectation::none()));
                 }
 
-                Ty::apply(TypeName::Tuple, Substs(ty_vec.into()))
+                Ty::apply(TypeCtor::Tuple, Substs(ty_vec.into()))
             }
             Expr::Array { exprs } => {
                 let elem_ty = match &expected.ty {
                     Ty::Apply(a_ty) => match a_ty.name {
-                        TypeName::Slice | TypeName::Array => {
+                        TypeCtor::Slice | TypeCtor::Array => {
                             Ty::clone(&a_ty.parameters.as_single())
                         }
                         _ => self.new_type_var(),
@@ -1056,23 +1056,23 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     self.infer_expr(*expr, &Expectation::has_type(elem_ty.clone()));
                 }
 
-                Ty::apply_one(TypeName::Array, elem_ty)
+                Ty::apply_one(TypeCtor::Array, elem_ty)
             }
             Expr::Literal(lit) => match lit {
-                Literal::Bool(..) => Ty::simple(TypeName::Bool),
+                Literal::Bool(..) => Ty::simple(TypeCtor::Bool),
                 Literal::String(..) => {
-                    Ty::apply_one(TypeName::Ref(Mutability::Shared), Ty::simple(TypeName::Str))
+                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
                 }
                 Literal::ByteString(..) => {
-                    let byte_type = Ty::simple(TypeName::Int(primitive::UncertainIntTy::Unsigned(
+                    let byte_type = Ty::simple(TypeCtor::Int(primitive::UncertainIntTy::Unsigned(
                         primitive::UintTy::U8,
                     )));
-                    let slice_type = Ty::apply_one(TypeName::Slice, byte_type);
-                    Ty::apply_one(TypeName::Ref(Mutability::Shared), slice_type)
+                    let slice_type = Ty::apply_one(TypeCtor::Slice, byte_type);
+                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type)
                 }
-                Literal::Char(..) => Ty::simple(TypeName::Char),
-                Literal::Int(_v, ty) => Ty::simple(TypeName::Int(*ty)),
-                Literal::Float(_v, ty) => Ty::simple(TypeName::Float(*ty)),
+                Literal::Char(..) => Ty::simple(TypeCtor::Char),
+                Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int(*ty)),
+                Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float(*ty)),
             },
         };
         // use a new type variable if we got Ty::Unknown here
@@ -1208,9 +1208,9 @@ impl InferTy {
         match self {
             InferTy::TypeVar(..) => Ty::Unknown,
             InferTy::IntVar(..) => {
-                Ty::simple(TypeName::Int(primitive::UncertainIntTy::Signed(primitive::IntTy::I32)))
+                Ty::simple(TypeCtor::Int(primitive::UncertainIntTy::Signed(primitive::IntTy::I32)))
             }
-            InferTy::FloatVar(..) => Ty::simple(TypeName::Float(
+            InferTy::FloatVar(..) => Ty::simple(TypeCtor::Float(
                 primitive::UncertainFloatTy::Known(primitive::FloatTy::F64),
             )),
         }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index a346879d8..72b1234bf 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -19,40 +19,40 @@ use crate::{
     generics::GenericParams,
     adt::VariantDef,
 };
-use super::{Ty, primitive, FnSig, Substs, TypeName};
+use super::{Ty, primitive, FnSig, Substs, TypeCtor};
 
 impl Ty {
     pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self {
         match type_ref {
-            TypeRef::Never => Ty::simple(TypeName::Never),
+            TypeRef::Never => Ty::simple(TypeCtor::Never),
             TypeRef::Tuple(inner) => {
                 let inner_tys =
                     inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
-                Ty::apply(TypeName::Tuple, Substs(inner_tys.into()))
+                Ty::apply(TypeCtor::Tuple, Substs(inner_tys.into()))
             }
             TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
             TypeRef::RawPtr(inner, mutability) => {
                 let inner_ty = Ty::from_hir(db, resolver, inner);
-                Ty::apply_one(TypeName::RawPtr(*mutability), inner_ty)
+                Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty)
             }
             TypeRef::Array(inner) => {
                 let inner_ty = Ty::from_hir(db, resolver, inner);
-                Ty::apply_one(TypeName::Array, inner_ty)
+                Ty::apply_one(TypeCtor::Array, inner_ty)
             }
             TypeRef::Slice(inner) => {
                 let inner_ty = Ty::from_hir(db, resolver, inner);
-                Ty::apply_one(TypeName::Slice, inner_ty)
+                Ty::apply_one(TypeCtor::Slice, inner_ty)
             }
             TypeRef::Reference(inner, mutability) => {
                 let inner_ty = Ty::from_hir(db, resolver, inner);
-                Ty::apply_one(TypeName::Ref(*mutability), inner_ty)
+                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
             }
             TypeRef::Placeholder => Ty::Unknown,
             TypeRef::Fn(params) => {
                 let inner_tys =
                     params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
                 let sig = Substs(inner_tys.into());
-                Ty::apply(TypeName::FnPtr, sig)
+                Ty::apply(TypeCtor::FnPtr, sig)
             }
             TypeRef::Error => Ty::Unknown,
         }
@@ -62,14 +62,14 @@ impl Ty {
         if let Some(name) = path.as_ident() {
             // TODO handle primitive type names in resolver as well?
             if let Some(int_ty) = primitive::UncertainIntTy::from_type_name(name) {
-                return Ty::simple(TypeName::Int(int_ty));
+                return Ty::simple(TypeCtor::Int(int_ty));
             } else if let Some(float_ty) = primitive::UncertainFloatTy::from_type_name(name) {
-                return Ty::simple(TypeName::Float(float_ty));
+                return Ty::simple(TypeCtor::Float(float_ty));
             } else if let Some(known) = name.as_known_name() {
                 match known {
-                    KnownName::Bool => return Ty::simple(TypeName::Bool),
-                    KnownName::Char => return Ty::simple(TypeName::Char),
-                    KnownName::Str => return Ty::simple(TypeName::Str),
+                    KnownName::Bool => return Ty::simple(TypeCtor::Bool),
+                    KnownName::Char => return Ty::simple(TypeCtor::Char),
+                    KnownName::Str => return Ty::simple(TypeCtor::Str),
                     _ => {}
                 }
             }
@@ -245,7 +245,7 @@ fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
     let generics = def.generic_params(db);
     let substs = make_substs(&generics);
-    Ty::apply(TypeName::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.into()), substs)
 }
 
 /// Build the declared type of a const.
@@ -287,7 +287,7 @@ fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
     }
     let generics = def.generic_params(db);
     let substs = make_substs(&generics);
-    Ty::apply(TypeName::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.into()), substs)
 }
 
 fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
@@ -315,7 +315,7 @@ fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) ->
     }
     let generics = def.parent_enum(db).generic_params(db);
     let substs = make_substs(&generics);
-    Ty::apply(TypeName::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.into()), substs)
 }
 
 fn make_substs(generics: &GenericParams) -> Substs {
@@ -331,12 +331,12 @@ fn make_substs(generics: &GenericParams) -> Substs {
 
 fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
     let generics = s.generic_params(db);
-    Ty::apply(TypeName::Adt(s.into()), make_substs(&generics))
+    Ty::apply(TypeCtor::Adt(s.into()), make_substs(&generics))
 }
 
 fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
     let generics = s.generic_params(db);
-    Ty::apply(TypeName::Adt(s.into()), make_substs(&generics))
+    Ty::apply(TypeCtor::Adt(s.into()), 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 06bfe85cd..9422bad84 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -10,7 +10,7 @@ use crate::{
     HirDatabase, Module, Crate, Name, Function, Trait,
     ids::TraitId,
     impl_block::{ImplId, ImplBlock, ImplItem},
-    ty::{Ty, TypeName},
+    ty::{Ty, TypeCtor},
     nameres::CrateModuleId,
 
 };
@@ -18,7 +18,7 @@ use crate::{
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TyFingerprint {
-    Apply(TypeName),
+    Apply(TypeCtor),
 }
 
 impl TyFingerprint {
@@ -112,7 +112,7 @@ impl CrateImplBlocks {
 fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
     match ty {
         Ty::Apply(a_ty) => match a_ty.name {
-            TypeName::Adt(def_id) => def_id.krate(db),
+            TypeCtor::Adt(def_id) => def_id.krate(db),
             _ => None,
         },
         _ => None,
diff --git a/crates/ra_hir/src/ty/op.rs b/crates/ra_hir/src/ty/op.rs
index f581004d2..1d230140b 100644
--- a/crates/ra_hir/src/ty/op.rs
+++ b/crates/ra_hir/src/ty/op.rs
@@ -1,5 +1,5 @@
 use crate::{ ty::ApplicationTy, expr::BinaryOp};
-use super::{Ty, TypeName, InferTy};
+use super::{Ty, TypeCtor, InferTy};
 
 pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
     match op {
@@ -10,7 +10,7 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
         | BinaryOp::LesserEqualTest
         | BinaryOp::GreaterEqualTest
         | BinaryOp::LesserTest
-        | BinaryOp::GreaterTest => Ty::simple(TypeName::Bool),
+        | BinaryOp::GreaterTest => Ty::simple(TypeCtor::Bool),
         BinaryOp::Assignment
         | BinaryOp::AddAssign
         | BinaryOp::SubAssign
@@ -33,7 +33,7 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
         | BinaryOp::BitwiseOr
         | BinaryOp::BitwiseXor => match rhs_ty {
             Ty::Apply(ApplicationTy { name, .. }) => match name {
-                TypeName::Int(..) | TypeName::Float(..) => rhs_ty,
+                TypeCtor::Int(..) | TypeCtor::Float(..) => rhs_ty,
                 _ => Ty::Unknown,
             },
             Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => rhs_ty,
@@ -45,14 +45,14 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
 
 pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
     match op {
-        BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::simple(TypeName::Bool),
+        BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::simple(TypeCtor::Bool),
         BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty {
             Ty::Apply(ApplicationTy { name, .. }) => match name {
-                TypeName::Int(..)
-                | TypeName::Float(..)
-                | TypeName::Str
-                | TypeName::Char
-                | TypeName::Bool => lhs_ty,
+                TypeCtor::Int(..)
+                | TypeCtor::Float(..)
+                | TypeCtor::Str
+                | TypeCtor::Char
+                | TypeCtor::Bool => lhs_ty,
                 _ => Ty::Unknown,
             },
             Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
@@ -83,7 +83,7 @@ pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
         | BinaryOp::BitwiseOr
         | BinaryOp::BitwiseXor => match lhs_ty {
             Ty::Apply(ApplicationTy { name, .. }) => match name {
-                TypeName::Int(..) | TypeName::Float(..) => lhs_ty,
+                TypeCtor::Int(..) | TypeCtor::Float(..) => lhs_ty,
                 _ => Ty::Unknown,
             },
             Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,