Make EnumVariant a GenericDef and simplify some code

Author: flodiebold

crates/ra_hir/src/generics.rs

@@ -11,8 +11,8 @@ use crate::{
     db::{AstDatabase, DefDatabase, HirDatabase},
     path::Path,
     type_ref::TypeRef,
-    AdtDef, AsName, Container, Enum, Function, HasSource, ImplBlock, Name, Struct, Trait,
-    TypeAlias, Union,
+    AdtDef, AsName, Container, Enum, EnumVariant, Function, HasSource, ImplBlock, Name, Struct,
+    Trait, TypeAlias, Union,
 };
 
 /// Data about a generic parameter (to a function, struct, impl, ...).
@@ -50,8 +50,11 @@ pub enum GenericDef {
     Trait(Trait),
     TypeAlias(TypeAlias),
     ImplBlock(ImplBlock),
+    // enum variants cannot have generics themselves, but their parent enums
+    // can, and this makes some code easier to write
+    EnumVariant(EnumVariant),
 }
-impl_froms!(GenericDef: Function, Struct, Union, Enum, Trait, TypeAlias, ImplBlock);
+impl_froms!(GenericDef: Function, Struct, Union, Enum, Trait, TypeAlias, ImplBlock, EnumVariant);
 
 impl GenericParams {
     pub(crate) fn generic_params_query(
@@ -62,6 +65,7 @@ impl GenericParams {
         let parent = match def {
             GenericDef::Function(it) => it.container(db).map(GenericDef::from),
             GenericDef::TypeAlias(it) => it.container(db).map(GenericDef::from),
+            GenericDef::EnumVariant(it) => Some(it.parent_enum(db).into()),
             GenericDef::Struct(_)
             | GenericDef::Union(_)
             | GenericDef::Enum(_)
@@ -86,6 +90,7 @@ impl GenericParams {
             }
             GenericDef::TypeAlias(it) => generics.fill(&*it.source(db).ast, start),
             GenericDef::ImplBlock(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::EnumVariant(_) => {}
         }
 
         Arc::new(generics)
@@ -184,6 +189,7 @@ impl GenericDef {
             GenericDef::Trait(inner) => inner.resolver(db),
             GenericDef::TypeAlias(inner) => inner.resolver(db),
             GenericDef::ImplBlock(inner) => inner.resolver(db),
+            GenericDef::EnumVariant(inner) => inner.parent_enum(db).resolver(db),
         }
     }
 }

crates/ra_hir/src/ty/infer.rs

@@ -849,12 +849,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
         if let Ty::Apply(a_ty) = callable_ty {
             if let TypeCtor::FnDef(def) = a_ty.ctor {
-                let generic_predicates = self.db.generic_predicates(match def {
-                    // TODO add helper function
-                    CallableDef::Function(f) => f.into(),
-                    CallableDef::Struct(s) => s.into(),
-                    CallableDef::EnumVariant(_e) => unimplemented!(),
-                });
+                let generic_predicates = self.db.generic_predicates(def.into());
                 for predicate in generic_predicates.iter() {
                     let predicate = predicate.clone().subst(&a_ty.parameters);
                     if let Some(obligation) = Obligation::from_predicate(predicate) {

crates/ra_hir/src/ty/lower.rs

@@ -509,3 +509,13 @@ pub enum CallableDef {
     EnumVariant(EnumVariant),
 }
 impl_froms!(CallableDef: Function, Struct, EnumVariant);
+
+impl From<CallableDef> for GenericDef {
+    fn from(def: CallableDef) -> GenericDef {
+        match def {
+            CallableDef::Function(f) => f.into(),
+            CallableDef::Struct(s) => s.into(),
+            CallableDef::EnumVariant(e) => e.into(),
+        }
+    }
+}

crates/ra_hir/src/ty/traits/chalk.rs

@@ -428,11 +428,7 @@ pub(crate) fn struct_datum_query(
                 CallableDef::Struct(s) => s.module(db).krate(db),
                 CallableDef::EnumVariant(v) => v.parent_enum(db).module(db).krate(db),
             } != Some(krate);
-            let generic_def: GenericDef = match callable {
-                CallableDef::Function(f) => f.into(),
-                CallableDef::Struct(s) => s.into(),
-                CallableDef::EnumVariant(v) => v.parent_enum(db).into(),
-            };
+            let generic_def: GenericDef = callable.into();
             let generic_params = generic_def.generic_params(db);
             let bound_vars = Substs::bound_vars(&generic_params);
             let where_clauses = convert_where_clauses(db, generic_def, &bound_vars);