Get rid of field_type again

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index edee99356b1b66c7322a73f369657c0d7dc43e89..ca9a7f7fa0adb9daeeca25d6679ef48573689c36 100644 (file)
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -514,8 +514,7 @@ pub fn name(&self, db: &dyn HirDatabase) -> Name {
 
     /// Returns the type as in the signature of the struct (i.e., with
     /// placeholder types for type parameters). Only use this in the context of
-    /// the field *definition*; if you've already got a variable of the struct
-    /// type, use `Type::field_type` to get to the field type.
+    /// the field definition.
     pub fn ty(&self, db: &dyn HirDatabase) -> Type {
         let var_id = self.parent.into();
         let generic_def_id: GenericDefId = match self.parent {
@@ -1944,18 +1943,6 @@ fn go(ty: &Ty) -> bool {
         }
     }
 
-    pub fn field_type(&self, db: &dyn HirDatabase, field: Field) -> Option<Type> {
-        let (adt_id, substs) = self.ty.as_adt()?;
-        let variant_id: hir_def::VariantId = field.parent.into();
-        if variant_id.adt_id() != adt_id {
-            return None;
-        }
-
-        let ty = db.field_types(variant_id).get(field.id)?.clone();
-        let ty = ty.substitute(&Interner, substs);
-        Some(self.derived(ty))
-    }
-
     pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
         let (variant_id, substs) = match self.ty.kind(&Interner) {
             &TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),

diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index d65dd7df08de2ef28e86f0474a0692cd3ae1ad73..3aa467e3ca304a5e5216f1125bc0d67f4978b5d3 100644 (file)
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -227,7 +227,7 @@ pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
     pub fn resolve_record_field(
         &self,
         field: &ast::RecordExprField,
-    ) -> Option<(Field, Option<Local>)> {
+    ) -> Option<(Field, Option<Local>, Type)> {
         self.imp.resolve_record_field(field)
     }
 
@@ -518,7 +518,10 @@ fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
         self.analyze(field.syntax()).resolve_field(self.db, field)
     }
 
-    fn resolve_record_field(&self, field: &ast::RecordExprField) -> Option<(Field, Option<Local>)> {
+    fn resolve_record_field(
+        &self,
+        field: &ast::RecordExprField,
+    ) -> Option<(Field, Option<Local>, Type)> {
         self.analyze(field.syntax()).resolve_record_field(self.db, field)
     }
 

diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index a1a9c727a6788b90d9cdea1674da468701829d94..5a3d80e8e3fbd691f15553cd680a0ff42ca4a1c1 100644 (file)
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -161,7 +161,7 @@ pub(crate) fn resolve_record_field(
         &self,
         db: &dyn HirDatabase,
         field: &ast::RecordExprField,
-    ) -> Option<(Field, Option<Local>)> {
+    ) -> Option<(Field, Option<Local>, Type)> {
         let record_expr = ast::RecordExpr::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
         let expr = ast::Expr::from(record_expr);
         let expr_id = self.body_source_map.as_ref()?.node_expr(InFile::new(self.file_id, &expr))?;
@@ -178,10 +178,13 @@ pub(crate) fn resolve_record_field(
                 _ => None,
             }
         };
+        let (_, subst) = self.infer.as_ref()?.type_of_expr.get(expr_id)?.as_adt()?;
         let variant = self.infer.as_ref()?.variant_resolution_for_expr(expr_id)?;
         let variant_data = variant.variant_data(db.upcast());
         let field = FieldId { parent: variant, local_id: variant_data.field(&local_name)? };
-        Some((field.into(), local))
+        let field_ty =
+            db.field_types(variant).get(field.local_id)?.clone().substitute(&Interner, subst);
+        Some((field.into(), local, Type::new_with_resolver(db, &self.resolver, field_ty)?))
     }
 
     pub(crate) fn resolve_record_pat_field(

diff --git a/crates/ide_assists/src/handlers/fix_visibility.rs b/crates/ide_assists/src/handlers/fix_visibility.rs
index 6c7824e551018c91d3bca64f830e5253babde39b..89f7b2c2c37975d063d550f7cf677a0f63972c7f 100644 (file)
--- a/crates/ide_assists/src/handlers/fix_visibility.rs
+++ b/crates/ide_assists/src/handlers/fix_visibility.rs
@@ -85,7 +85,7 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
 
 fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let record_field: ast::RecordExprField = ctx.find_node_at_offset()?;
-    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
+    let (record_field_def, _, _) = ctx.sema.resolve_record_field(&record_field)?;
 
     let current_module = ctx.sema.scope(record_field.syntax()).module()?;
     let visibility = record_field_def.visibility(ctx.db());

diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index efaf4792f470a913a2beffe05c0337084972fce0..1ec59ff804d602f2f17e7f275e3bc87ed118e723 100644 (file)
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -339,13 +339,12 @@ fn expected_type_and_name(&self) -> (Option<Type>, Option<NameOrNameRef>) {
                         cov_mark::hit!(expected_type_struct_field_without_leading_char);
                         // wouldn't try {} be nice...
                         (|| {
-                            let record_ty = self.sema.type_of_expr(&ast::Expr::cast(node.parent()?)?)?;
                             let expr_field = self.token.prev_sibling_or_token()?
-                            .into_node()
+                                      .into_node()
                                       .and_then(|node| ast::RecordExprField::cast(node))?;
-                            let field = self.sema.resolve_record_field(&expr_field)?.0;
+                            let (_, _, ty) = self.sema.resolve_record_field(&expr_field)?;
                             Some((
-                                record_ty.field_type(self.db, field),
+                                Some(ty),
                                 expr_field.field_name().map(NameOrNameRef::NameRef),
                             ))
                         })().unwrap_or((None, None))

diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index de0dc2a40f0b4544b23954e21f781314af29a79b..1dcccbb8be7cb436e06fe5e6fa2fb3c79159ec30 100644 (file)
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -311,7 +311,7 @@ pub fn classify(
         }
 
         if let Some(record_field) = ast::RecordExprField::for_field_name(name_ref) {
-            if let Some((field, local)) = sema.resolve_record_field(&record_field) {
+            if let Some((field, local, _)) = sema.resolve_record_field(&record_field) {
                 let field = Definition::Field(field);
                 let res = match local {
                     None => NameRefClass::Definition(field),