4 files changed, 84 insertions, 10 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 13080b5aa..29331bea5 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -477,7 +477,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
                 (ty, Some(var.into()))
             }
-            TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None),
+            TypableDef::Type(_) | TypableDef::Function(_) | TypableDef::Enum(_) => {
+                (Ty::Unknown, None)
+            }
         }
     }
 
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 63e13a30e..a11d964c8 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -10,7 +10,7 @@ use std::sync::Arc;
 
 use crate::{
     Function, Struct, StructField, Enum, EnumVariant, Path, Name,
-    ModuleDef,
+    ModuleDef, Type,
     HirDatabase,
     type_ref::TypeRef,
     name::KnownName,
@@ -109,7 +109,7 @@ impl Ty {
         };
         let ty = db.type_for_def(typable, Namespace::Types);
         let substs = Ty::substs_from_path(db, resolver, path, typable);
-        ty.apply_substs(substs)
+        ty.subst(&substs)
     }
 
     pub(super) fn substs_from_path_segment(
@@ -124,6 +124,7 @@ impl Ty {
             TypableDef::Struct(s) => s.generic_params(db),
             TypableDef::Enum(e) => e.generic_params(db),
             TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db),
+            TypableDef::Type(t) => t.generic_params(db),
         };
         let parent_param_count = def_generics.count_parent_params();
         substs.extend((0..parent_param_count).map(|_| Ty::Unknown));
@@ -159,9 +160,10 @@ impl Ty {
     ) -> Substs {
         let last = path.segments.last().expect("path should have at least one segment");
         let segment = match resolved {
-            TypableDef::Function(_) => last,
-            TypableDef::Struct(_) => last,
-            TypableDef::Enum(_) => last,
+            TypableDef::Function(_)
+            | TypableDef::Struct(_)
+            | TypableDef::Enum(_)
+            | TypableDef::Type(_) => last,
             TypableDef::EnumVariant(_) => {
                 // the generic args for an enum variant may be either specified
                 // on the segment referring to the enum, or on the segment
@@ -194,11 +196,13 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
         (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s),
         (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e),
         (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
+        (TypableDef::Type(t), Namespace::Types) => type_for_type_alias(db, t),
 
         // 'error' cases:
         (TypableDef::Function(_), Namespace::Types) => Ty::Unknown,
         (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown,
         (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown,
+        (TypableDef::Type(_), Namespace::Values) => Ty::Unknown,
     }
 }
 
@@ -264,7 +268,7 @@ fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) ->
         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
         .collect::<Vec<_>>();
     let substs = make_substs(&generics);
-    let output = type_for_enum(db, def.parent_enum(db)).apply_substs(substs.clone());
+    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 }
 }
@@ -298,14 +302,24 @@ fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
     }
 }
 
+fn type_for_type_alias(db: &impl HirDatabase, t: Type) -> Ty {
+    let generics = t.generic_params(db);
+    let resolver = t.resolver(db);
+    let type_ref = t.type_ref(db);
+    let substs = make_substs(&generics);
+    let inner = Ty::from_hir(db, &resolver, &type_ref);
+    inner.subst(&substs)
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum TypableDef {
     Function(Function),
     Struct(Struct),
     Enum(Enum),
     EnumVariant(EnumVariant),
+    Type(Type),
 }
-impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant);
+impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant, Type);
 
 impl From<ModuleDef> for Option<TypableDef> {
     fn from(def: ModuleDef) -> Option<TypableDef> {
@@ -314,11 +328,11 @@ impl From<ModuleDef> for Option<TypableDef> {
             ModuleDef::Struct(s) => s.into(),
             ModuleDef::Enum(e) => e.into(),
             ModuleDef::EnumVariant(v) => v.into(),
+            ModuleDef::Type(t) => t.into(),
             ModuleDef::Const(_)
             | ModuleDef::Static(_)
             | ModuleDef::Module(_)
-            | ModuleDef::Trait(_)
-            | ModuleDef::Type(_) => return None,
+            | ModuleDef::Trait(_) => return None,
         };
         Some(res)
     }
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_type_alias.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_type_alias.snap
new file mode 100644
index 000000000..241c08353
--- /dev/null
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_type_alias.snap
@@ -0,0 +1,23 @@
+---
+created: "2019-02-24T16:13:47.561870283Z"
+creator: [email protected]
+source: crates/ra_hir/src/ty/tests.rs
+expression: "&result"
+---
+[117; 118) 'x': A<u32, i128>
+[125; 126) 'y': A<&str, u128>
+[139; 140) 'z': A<u8, i8>
+[155; 212) '{     ...z.y; }': ()
+[161; 162) 'x': A<u32, i128>
+[161; 164) 'x.x': u32
+[170; 171) 'x': A<u32, i128>
+[170; 173) 'x.y': i128
+[179; 180) 'y': A<&str, u128>
+[179; 182) 'y.x': &str
+[188; 189) 'y': A<&str, u128>
+[188; 191) 'y.y': u128
+[197; 198) 'z': A<u8, i8>
+[197; 200) 'z.x': u8
+[206; 207) 'z': A<u8, i8>
+[206; 209) 'z.y': i8
+
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index d0da34677..642259225 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -741,6 +741,41 @@ fn test() {
 }
 
 #[test]
+fn infer_type_alias() {
+    check_inference(
+        "infer_type_alias",
+        r#"
+struct A<X, Y> { x: X, y: Y };
+type Foo = A<u32, i128>;
+type Bar<T> = A<T, u128>;
+type Baz<U, V> = A<V, U>;
+fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
+    x.x;
+    x.y;
+    y.x;
+    y.y;
+    z.x;
+    z.y;
+}
+"#,
+    )
+}
+
+#[test]
+#[should_panic] // we currently can't handle this
+fn recursive_type_alias() {
+    check_inference(
+        "recursive_type_alias",
+        r#"
+struct A<X> {};
+type Foo = Foo;
+type Bar = A<Bar>;
+fn test(x: Foo) {}
+"#,
+    )
+}
+
+#[test]
 fn no_panic_on_field_of_enum() {
     check_inference(
         "no_panic_on_field_of_enum",