1 files changed, 202 insertions, 9 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index f7fc80d4e..821f919d4 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -10,10 +10,10 @@ use hir_def::{
     docs::Documentation,
     per_ns::PerNs,
     resolver::{HasResolver, TypeNs},
-    type_ref::TypeRef,
-    AstItemDef, ConstId, ContainerId, EnumId, FunctionId, GenericDefId, HasModule, ImplId,
-    LocalEnumVariantId, LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId,
-    StaticId, StructId, TraitId, TypeAliasId, UnionId,
+    type_ref::{Mutability, TypeRef},
+    AdtId, AstItemDef, ConstId, ContainerId, DefWithBodyId, EnumId, FunctionId, GenericDefId,
+    HasModule, ImplId, LocalEnumVariantId, LocalImportId, LocalModuleId, LocalStructFieldId,
+    Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
 };
 use hir_expand::{
     diagnostics::DiagnosticSink,
@@ -26,8 +26,12 @@ use ra_syntax::{ast, AstNode, SyntaxNode};
 use crate::{
     db::{DefDatabase, HirDatabase},
     expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
-    ty::{InferenceResult, Namespace, TraitRef},
-    Either, Name, Source, Ty,
+    ty::display::HirFormatter,
+    ty::{
+        self, InEnvironment, InferenceResult, Namespace, TraitEnvironment, TraitRef, Ty, TypeCtor,
+        TypeWalk,
+    },
+    CallableDef, Either, HirDisplay, Name, Source,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -379,6 +383,28 @@ impl Union {
     pub fn ty(self, db: &impl HirDatabase) -> Ty {
         db.type_for_def(self.into(), Namespace::Types)
     }
+
+    pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
+        db.union_data(self.id)
+            .variant_data
+            .fields()
+            .iter()
+            .map(|(id, _)| StructField { parent: self.into(), id })
+            .collect()
+    }
+
+    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
+        db.union_data(self.id)
+            .variant_data
+            .fields()
+            .iter()
+            .find(|(_id, data)| data.name == *name)
+            .map(|(id, _)| StructField { parent: self.into(), id })
+    }
+
+    fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
+        db.union_data(self.id).variant_data.clone()
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -469,6 +495,10 @@ pub enum Adt {
 impl_froms!(Adt: Struct, Union, Enum);
 
 impl Adt {
+    pub fn has_non_default_type_params(self, db: &impl HirDatabase) -> bool {
+        let subst = db.generic_defaults(self.into());
+        subst.iter().any(|ty| ty == &Ty::Unknown)
+    }
     pub fn ty(self, db: &impl HirDatabase) -> Ty {
         match self {
             Adt::Struct(it) => it.ty(db),
@@ -493,14 +523,16 @@ impl Adt {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum VariantDef {
     Struct(Struct),
+    Union(Union),
     EnumVariant(EnumVariant),
 }
-impl_froms!(VariantDef: Struct, EnumVariant);
+impl_froms!(VariantDef: Struct, Union, EnumVariant);
 
 impl VariantDef {
     pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
         match self {
             VariantDef::Struct(it) => it.fields(db),
+            VariantDef::Union(it) => it.fields(db),
             VariantDef::EnumVariant(it) => it.fields(db),
         }
     }
@@ -508,6 +540,7 @@ impl VariantDef {
     pub(crate) fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
         match self {
             VariantDef::Struct(it) => it.field(db, name),
+            VariantDef::Union(it) => it.field(db, name),
             VariantDef::EnumVariant(it) => it.field(db, name),
         }
     }
@@ -515,6 +548,7 @@ impl VariantDef {
     pub fn module(self, db: &impl HirDatabase) -> Module {
         match self {
             VariantDef::Struct(it) => it.module(db),
+            VariantDef::Union(it) => it.module(db),
             VariantDef::EnumVariant(it) => it.module(db),
         }
     }
@@ -522,6 +556,7 @@ impl VariantDef {
     pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
         match self {
             VariantDef::Struct(it) => it.variant_data(db),
+            VariantDef::Union(it) => it.variant_data(db),
             VariantDef::EnumVariant(it) => it.variant_data(db),
         }
     }
@@ -777,6 +812,11 @@ pub struct TypeAlias {
 }
 
 impl TypeAlias {
+    pub fn has_non_default_type_params(self, db: &impl HirDatabase) -> bool {
+        let subst = db.generic_defaults(self.id.into());
+        subst.iter().any(|ty| ty == &Ty::Unknown)
+    }
+
     pub fn module(self, db: &impl DefDatabase) -> Module {
         Module { id: self.id.lookup(db).module(db) }
     }
@@ -927,9 +967,14 @@ impl Local {
         self.parent.module(db)
     }
 
-    pub fn ty(self, db: &impl HirDatabase) -> Ty {
+    pub fn ty(self, db: &impl HirDatabase) -> Type {
         let infer = db.infer(self.parent);
-        infer[self.pat_id].clone()
+        let ty = infer[self.pat_id].clone();
+        let def = DefWithBodyId::from(self.parent);
+        let resolver = def.resolver(db);
+        let krate = def.module(db).krate;
+        let environment = TraitEnvironment::lower(db, &resolver);
+        Type { krate, ty: InEnvironment { value: ty, environment } }
     }
 
     pub fn source(self, db: &impl HirDatabase) -> Source<Either<ast::BindPat, ast::SelfParam>> {
@@ -952,6 +997,15 @@ pub struct ImplBlock {
 }
 
 impl ImplBlock {
+    pub fn all_in_crate(db: &impl HirDatabase, krate: Crate) -> Vec<ImplBlock> {
+        let impls = db.impls_in_crate(krate.crate_id);
+        impls.all_impls().map(Self::from).collect()
+    }
+    pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplBlock> {
+        let impls = db.impls_in_crate(krate.crate_id);
+        impls.lookup_impl_blocks_for_trait(trait_).map(Self::from).collect()
+    }
+
     pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
         db.impl_data(self.id).target_trait.clone()
     }
@@ -986,6 +1040,145 @@ impl ImplBlock {
     }
 }
 
+#[derive(Clone, PartialEq, Eq)]
+pub struct Type {
+    pub(crate) krate: CrateId,
+    pub(crate) ty: InEnvironment<Ty>,
+}
+
+impl Type {
+    pub fn is_bool(&self) -> bool {
+        match &self.ty.value {
+            Ty::Apply(a_ty) => match a_ty.ctor {
+                TypeCtor::Bool => true,
+                _ => false,
+            },
+            _ => false,
+        }
+    }
+
+    pub fn is_mutable_reference(&self) -> bool {
+        match &self.ty.value {
+            Ty::Apply(a_ty) => match a_ty.ctor {
+                TypeCtor::Ref(Mutability::Mut) => true,
+                _ => false,
+            },
+            _ => false,
+        }
+    }
+
+    pub fn is_unknown(&self) -> bool {
+        match &self.ty.value {
+            Ty::Unknown => true,
+            _ => false,
+        }
+    }
+
+    // FIXME: this method is broken, as it doesn't take closures into account.
+    pub fn as_callable(&self) -> Option<CallableDef> {
+        Some(self.ty.value.as_callable()?.0)
+    }
+
+    pub fn contains_unknown(&self) -> bool {
+        return go(&self.ty.value);
+
+        fn go(ty: &Ty) -> bool {
+            match ty {
+                Ty::Unknown => true,
+                Ty::Apply(a_ty) => a_ty.parameters.iter().any(go),
+                _ => false,
+            }
+        }
+    }
+
+    pub fn fields(&self, db: &impl HirDatabase) -> Vec<(StructField, Type)> {
+        if let Ty::Apply(a_ty) = &self.ty.value {
+            match a_ty.ctor {
+                ty::TypeCtor::Adt(AdtId::StructId(s)) => {
+                    let var_def = s.into();
+                    return db
+                        .field_types(var_def)
+                        .iter()
+                        .map(|(local_id, ty)| {
+                            let def = StructField { parent: var_def.into(), id: local_id };
+                            let ty = ty.clone().subst(&a_ty.parameters);
+                            (def, self.derived(ty))
+                        })
+                        .collect();
+                }
+                _ => {}
+            }
+        };
+        Vec::new()
+    }
+
+    pub fn tuple_fields(&self, _db: &impl HirDatabase) -> Vec<Type> {
+        let mut res = Vec::new();
+        if let Ty::Apply(a_ty) = &self.ty.value {
+            match a_ty.ctor {
+                ty::TypeCtor::Tuple { .. } => {
+                    for ty in a_ty.parameters.iter() {
+                        let ty = ty.clone().subst(&a_ty.parameters);
+                        res.push(self.derived(ty));
+                    }
+                }
+                _ => {}
+            }
+        };
+        res
+    }
+
+    pub fn variant_fields(
+        &self,
+        db: &impl HirDatabase,
+        def: VariantDef,
+    ) -> Vec<(StructField, Type)> {
+        // FIXME: check that ty and def match
+        match &self.ty.value {
+            Ty::Apply(a_ty) => def
+                .fields(db)
+                .into_iter()
+                .map(|it| (it, self.derived(it.ty(db).subst(&a_ty.parameters))))
+                .collect(),
+            _ => Vec::new(),
+        }
+    }
+
+    pub fn autoderef<'a>(&'a self, db: &'a impl HirDatabase) -> impl Iterator<Item = Type> + 'a {
+        // There should be no inference vars in types passed here
+        // FIXME check that?
+        let canonical = crate::ty::Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let environment = self.ty.environment.clone();
+        let ty = InEnvironment { value: canonical, environment: environment.clone() };
+        ty::autoderef(db, Some(self.krate), ty)
+            .map(|canonical| canonical.value)
+            .map(move |ty| self.derived(ty))
+    }
+
+    // FIXME: remove
+    pub fn into_ty(self) -> Ty {
+        self.ty.value
+    }
+
+    pub fn as_adt(&self) -> Option<Adt> {
+        let (adt, _subst) = self.ty.value.as_adt()?;
+        Some(adt)
+    }
+
+    fn derived(&self, ty: Ty) -> Type {
+        Type {
+            krate: self.krate,
+            ty: InEnvironment { value: ty, environment: self.ty.environment.clone() },
+        }
+    }
+}
+
+impl HirDisplay for Type {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> std::fmt::Result {
+        self.ty.value.hir_fmt(f)
+    }
+}
+
 /// For IDE only
 pub enum ScopeDef {
     ModuleDef(ModuleDef),