Id-ify Ty::Adt

5 files changed, 25 insertions, 20 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 6fd00d457..fce45321d 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -598,10 +598,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         trait_.associated_type_by_name(self.db, &name::OUTPUT_TYPE)
     }
 
-    fn resolve_boxed_box(&self) -> Option<Adt> {
+    fn resolve_boxed_box(&self) -> Option<AdtId> {
         let path = known::std_boxed_box();
         let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
-        Some(Adt::Struct(struct_.into()))
+        Some(struct_.into())
     }
 }
 
diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index bb9a2e427..5ed4470af 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -4,14 +4,14 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
 
-use hir_def::{lang_item::LangItemTarget, resolver::Resolver};
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver, AdtId};
 use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
     db::HirDatabase,
     ty::{autoderef, Substs, Ty, TypeCtor, TypeWalk},
-    Adt, Mutability,
+    Mutability,
 };
 
 use super::{InEnvironment, InferTy, InferenceContext, TypeVarValue};
@@ -242,11 +242,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             // - T is not part of the type of any other fields
             // - Bar<T>: Unsize<Bar<U>>, if the last field of Foo has type Bar<T>
             (
-                ty_app!(TypeCtor::Adt(Adt::Struct(struct1)), st1),
-                ty_app!(TypeCtor::Adt(Adt::Struct(struct2)), st2),
+                ty_app!(TypeCtor::Adt(AdtId::StructId(struct1)), st1),
+                ty_app!(TypeCtor::Adt(AdtId::StructId(struct2)), st2),
             ) if struct1 == struct2 => {
-                let field_tys = self.db.field_types(struct1.id.into());
-                let struct_data = self.db.struct_data(struct1.id);
+                let field_tys = self.db.field_types((*struct1).into());
+                let struct_data = self.db.struct_data(*struct1);
 
                 let mut fields = struct_data.variant_data.fields().iter();
                 let (last_field_id, _data) = fields.next_back()?;
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 316cdc880..3d0895dc6 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -8,7 +8,7 @@ use hir_def::{
     generics::GenericParams,
     path::{GenericArg, GenericArgs},
     resolver::resolver_for_expr,
-    ContainerId, Lookup,
+    AdtId, ContainerId, Lookup, StructFieldId,
 };
 use hir_expand::name;
 
@@ -20,7 +20,7 @@ use crate::{
         Mutability, Namespace, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
         TypeCtor, TypeWalk, Uncertain,
     },
-    Adt, Name,
+    Name,
 };
 
 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
@@ -259,14 +259,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         TypeCtor::Tuple { .. } => name
                             .as_tuple_index()
                             .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
-                        TypeCtor::Adt(Adt::Struct(s)) => s.field(self.db, name).map(|field| {
-                            self.write_field_resolution(tgt_expr, field);
-                            self.db.field_types(s.id.into())[field.id]
-                                .clone()
-                                .subst(&a_ty.parameters)
-                        }),
+                        TypeCtor::Adt(AdtId::StructId(s)) => {
+                            self.db.struct_data(s).variant_data.field(name).map(|local_id| {
+                                let field = StructFieldId { parent: s.into(), local_id }.into();
+                                self.write_field_resolution(tgt_expr, field);
+                                self.db.field_types(s.into())[field.id]
+                                    .clone()
+                                    .subst(&a_ty.parameters)
+                            })
+                        }
                         // FIXME:
-                        TypeCtor::Adt(Adt::Union(_)) => None,
+                        TypeCtor::Adt(AdtId::UnionId(_)) => None,
                         _ => None,
                     },
                     _ => None,
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index d7d4bb0d6..485871e69 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -762,7 +762,7 @@ fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt>) -> Ty {
     let adt = adt.into();
     let adt_id: AdtId = adt.into();
     let generics = db.generic_params(adt_id.into());
-    Ty::apply(TypeCtor::Adt(adt), Substs::identity(&generics))
+    Ty::apply(TypeCtor::Adt(adt_id), Substs::identity(&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 c5ab690eb..7f0ff2e8c 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -5,7 +5,7 @@
 use std::sync::Arc;
 
 use arrayvec::ArrayVec;
-use hir_def::{lang_item::LangItemTarget, resolver::Resolver, AstItemDef};
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver, AstItemDef, HasModule};
 use rustc_hash::FxHashMap;
 
 use crate::{
@@ -102,7 +102,9 @@ fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayV
 
     let lang_item_targets = match ty {
         Ty::Apply(a_ty) => match a_ty.ctor {
-            TypeCtor::Adt(def_id) => return Some(std::iter::once(def_id.krate(db)?).collect()),
+            TypeCtor::Adt(def_id) => {
+                return Some(std::iter::once(def_id.module(db).krate.into()).collect())
+            }
             TypeCtor::Bool => lang_item_crate!("bool"),
             TypeCtor::Char => lang_item_crate!("char"),
             TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {