1 files changed, 17 insertions, 5 deletions

diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index b66b8e4a5..4a9b725d1 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -11,6 +11,7 @@ use std::sync::Arc;
 use crate::{
     Function, Struct, StructField, Enum, EnumVariant, Path, Name,
     ModuleDef, TypeAlias,
+    Const,
     HirDatabase,
     type_ref::TypeRef,
     name::KnownName,
@@ -125,6 +126,7 @@ impl Ty {
             TypableDef::Enum(e) => e.generic_params(db),
             TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db),
             TypableDef::TypeAlias(t) => t.generic_params(db),
+            TypableDef::Const(_) => GenericParams::default().into(),
         };
         let parent_param_count = def_generics.count_parent_params();
         substs.extend((0..parent_param_count).map(|_| Ty::Unknown));
@@ -163,6 +165,7 @@ impl Ty {
             TypableDef::Function(_)
             | TypableDef::Struct(_)
             | TypableDef::Enum(_)
+            | TypableDef::Const(_)
             | TypableDef::TypeAlias(_) => last,
             TypableDef::EnumVariant(_) => {
                 // the generic args for an enum variant may be either specified
@@ -197,12 +200,14 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
         (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e),
         (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
         (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t),
+        (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c),
 
         // 'error' cases:
         (TypableDef::Function(_), Namespace::Types) => Ty::Unknown,
         (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown,
         (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown,
         (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown,
+        (TypableDef::Const(_), Namespace::Types) => Ty::Unknown,
     }
 }
 
@@ -233,6 +238,14 @@ fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
     Ty::FnDef { def: def.into(), sig, name, substs }
 }
 
+/// Build the declared type of a const.
+fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty {
+    let signature = def.signature(db);
+    let resolver = def.resolver(db);
+
+    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 {
     let var_data = def.variant_data(db);
@@ -318,8 +331,9 @@ pub enum TypableDef {
     Enum(Enum),
     EnumVariant(EnumVariant),
     TypeAlias(TypeAlias),
+    Const(Const),
 }
-impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant, TypeAlias);
+impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant, TypeAlias, Const);
 
 impl From<ModuleDef> for Option<TypableDef> {
     fn from(def: ModuleDef) -> Option<TypableDef> {
@@ -329,10 +343,8 @@ impl From<ModuleDef> for Option<TypableDef> {
             ModuleDef::Enum(e) => e.into(),
             ModuleDef::EnumVariant(v) => v.into(),
             ModuleDef::TypeAlias(t) => t.into(),
-            ModuleDef::Const(_)
-            | ModuleDef::Static(_)
-            | ModuleDef::Module(_)
-            | ModuleDef::Trait(_) => return None,
+            ModuleDef::Const(v) => v.into(),
+            ModuleDef::Static(_) | ModuleDef::Module(_) | ModuleDef::Trait(_) => return None,
         };
         Some(res)
     }