Merge pull request #19063 from davidbarsky/davidbarsky/backout-struct-default-fields

internal: backout `hir-*` changes from #19001

Author: davidbarsky

src/tools/rust-analyzer/crates/hir-def/src/data/adt.rs

@@ -85,7 +85,6 @@ pub struct FieldData {
     pub name: Name,
     pub type_ref: TypeRefId,
     pub visibility: RawVisibility,
-    pub has_default: bool,
 }
 
 fn repr_from_value(
@@ -479,6 +478,5 @@ fn lower_field(
         name: field.name.clone(),
         type_ref: field.type_ref,
         visibility: item_tree[override_visibility.unwrap_or(field.visibility)].clone(),
-        has_default: field.has_default,
     }
 }

src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs

@@ -25,7 +25,7 @@ use crate::{
     db::DefDatabase,
     hir::{
         Array, AsmOperand, Binding, BindingId, Expr, ExprId, ExprOrPatId, Label, LabelId, Pat,
-        PatId, RecordFieldPat, Spread, Statement,
+        PatId, RecordFieldPat, Statement,
     },
     nameres::DefMap,
     path::{ModPath, Path},
@@ -362,7 +362,7 @@ impl ExpressionStore {
                 for field in fields.iter() {
                     f(field.expr);
                 }
-                if let &Spread::Base(expr) = spread {
+                if let &Some(expr) = spread {
                     f(expr);
                 }
             }
@@ -490,7 +490,7 @@ impl ExpressionStore {
                 for field in fields.iter() {
                     f(field.expr);
                 }
-                if let &Spread::Base(expr) = spread {
+                if let &Some(expr) = spread {
                     f(expr);
                 }
             }

src/tools/rust-analyzer/crates/hir-def/src/expr_store/body.rs

@@ -122,9 +122,6 @@ impl Body {
                     src.map(|it| it.expr())
                 }
                 DefWithBodyId::InTypeConstId(c) => c.lookup(db).id.map(|_| c.source(db).expr()),
-                DefWithBodyId::FieldId(f) => {
-                    f.record_field_source(db).map(|it| it.and_then(|it| it.expr()))
-                }
             }
         };
         let module = def.module(db);

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs

@@ -45,7 +45,7 @@ use crate::{
         },
         Array, Binding, BindingAnnotation, BindingId, BindingProblems, CaptureBy, ClosureKind,
         Expr, ExprId, Item, Label, LabelId, Literal, LiteralOrConst, MatchArm, Movability,
-        OffsetOf, Pat, PatId, RecordFieldPat, RecordLitField, Spread, Statement,
+        OffsetOf, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
     },
     item_scope::BuiltinShadowMode,
     lang_item::LangItem,
@@ -90,7 +90,6 @@ pub(super) fn lower_body(
         DefWithBodyId::ConstId(it) => db.attrs(it.into()),
         DefWithBodyId::InTypeConstId(_) => Attrs::EMPTY,
         DefWithBodyId::VariantId(it) => db.attrs(it.into()),
-        DefWithBodyId::FieldId(it) => db.attrs(it.into()),
     }
     .rust_analyzer_tool()
     .any(|attr| *attr.path() == tool_path![skip]);
@@ -169,7 +168,6 @@ pub(super) fn lower_body(
                     Awaitable::No("constant")
                 }
                 DefWithBodyId::VariantId(..) => Awaitable::No("enum variant"),
-                DefWithBodyId::FieldId(..) => Awaitable::No("field"),
             }
         },
     );
@@ -602,13 +600,10 @@ impl ExprCollector<'_> {
                             Some(RecordLitField { name, expr })
                         })
                         .collect();
-                    let spread = nfl.spread().map(|s| self.collect_expr(s)).map_or_else(
-                        || if nfl.dotdot_token().is_some() { Spread::Yes } else { Spread::No },
-                        Spread::Base,
-                    );
+                    let spread = nfl.spread().map(|s| self.collect_expr(s));
                     Expr::RecordLit { path, fields, spread }
                 } else {
-                    Expr::RecordLit { path, fields: Box::default(), spread: Spread::No }
+                    Expr::RecordLit { path, fields: Box::default(), spread: None }
                 };
 
                 self.alloc_expr(record_lit, syntax_ptr)

src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs

@@ -8,10 +8,9 @@ use span::Edition;
 use crate::{
     hir::{
         Array, BindingAnnotation, CaptureBy, ClosureKind, Literal, LiteralOrConst, Movability,
-        Spread, Statement,
+        Statement,
     },
     pretty::{print_generic_args, print_path, print_type_ref},
-    VariantId,
 };
 
 use super::*;
@@ -57,32 +56,6 @@ pub(super) fn print_body_hir(
                 loc.id.item_tree(db)[loc.id.value].name.display(db.upcast(), edition),
             )
         }
-        DefWithBodyId::FieldId(it) => {
-            let parent_name: String = match it.parent {
-                VariantId::EnumVariantId(it) => {
-                    let loc = it.lookup(db);
-                    let enum_loc = loc.parent.lookup(db);
-                    format!(
-                        "{}::{}",
-                        enum_loc.id.item_tree(db)[enum_loc.id.value]
-                            .name
-                            .display(db.upcast(), edition),
-                        loc.id.item_tree(db)[loc.id.value].name.display(db.upcast(), edition),
-                    )
-                }
-                VariantId::StructId(it) => it
-                    .lookup(db)
-                    .id
-                    .resolved(db, |it| it.name.display(db.upcast(), edition).to_string()),
-                VariantId::UnionId(it) => it
-                    .lookup(db)
-                    .id
-                    .resolved(db, |it| it.name.display(db.upcast(), edition).to_string()),
-            };
-            let variant_data = it.parent.variant_data(db);
-            let field_name = &variant_data.fields()[it.local_id].name;
-            format!("field {}.{}", parent_name, field_name.display(db.upcast(), edition),)
-        }
     };
 
     let mut p = Printer {
@@ -412,16 +385,10 @@ impl Printer<'_> {
                         p.print_expr(field.expr);
                         wln!(p, ",");
                     }
-                    match spread {
-                        Spread::No => {}
-                        Spread::Yes => {
-                            w!(p, "..");
-                        }
-                        Spread::Base(expr) => {
-                            w!(p, "..");
-                            p.print_expr(*expr);
-                            wln!(p);
-                        }
+                    if let Some(spread) = spread {
+                        w!(p, "..");
+                        p.print_expr(*spread);
+                        wln!(p);
                     }
                 });
                 w!(self, "}}");

src/tools/rust-analyzer/crates/hir-def/src/hir.rs

@@ -251,7 +251,7 @@ pub enum Expr {
     RecordLit {
         path: Option<Box<Path>>,
         fields: Box<[RecordLitField]>,
-        spread: Spread,
+        spread: Option<ExprId>,
     },
     Field {
         expr: ExprId,
@@ -478,13 +478,6 @@ pub struct RecordLitField {
     pub expr: ExprId,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Spread {
-    No,
-    Yes,
-    Base(ExprId),
-}
-
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Statement {
     Let {

src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs

@@ -1007,7 +1007,6 @@ pub struct Field {
     pub name: Name,
     pub type_ref: TypeRefId,
     pub visibility: RawVisibilityId,
-    pub has_default: bool,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]

src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs

@@ -319,9 +319,8 @@ impl<'a> Ctx<'a> {
         };
         let visibility = self.lower_visibility(field);
         let type_ref = TypeRef::from_ast_opt(body_ctx, field.ty());
-        let has_default = field.expr().is_some();
 
-        Field { name, type_ref, visibility, has_default }
+        Field { name, type_ref, visibility }
     }
 
     fn lower_tuple_field(
@@ -333,7 +332,7 @@ impl<'a> Ctx<'a> {
         let name = Name::new_tuple_field(idx);
         let visibility = self.lower_visibility(field);
         let type_ref = TypeRef::from_ast_opt(body_ctx, field.ty());
-        Field { name, type_ref, visibility, has_default: false }
+        Field { name, type_ref, visibility }
     }
 
     fn lower_union(&mut self, union: &ast::Union) -> Option<FileItemTreeId<Union>> {

src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs

@@ -135,9 +135,7 @@ impl Printer<'_> {
                 self.whitespace();
                 w!(self, "{{");
                 self.indented(|this| {
-                    for (idx, Field { name, type_ref, visibility, has_default: _ }) in
-                        fields.iter().enumerate()
-                    {
+                    for (idx, Field { name, type_ref, visibility }) in fields.iter().enumerate() {
                         this.print_attrs_of(
                             AttrOwner::Field(parent, Idx::from_raw(RawIdx::from(idx as u32))),
                             "\n",
@@ -153,9 +151,7 @@ impl Printer<'_> {
             FieldsShape::Tuple => {
                 w!(self, "(");
                 self.indented(|this| {
-                    for (idx, Field { name, type_ref, visibility, has_default: _ }) in
-                        fields.iter().enumerate()
-                    {
+                    for (idx, Field { name, type_ref, visibility }) in fields.iter().enumerate() {
                         this.print_attrs_of(
                             AttrOwner::Field(parent, Idx::from_raw(RawIdx::from(idx as u32))),
                             "\n",

src/tools/rust-analyzer/crates/hir-def/src/lib.rs

@@ -55,7 +55,6 @@ pub mod visibility;
 
 use intern::Interned;
 pub use rustc_abi as layout;
-use src::HasSource;
 use triomphe::Arc;
 
 #[cfg(test)]
@@ -78,7 +77,6 @@ use hir_expand::{
     builtin::{BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerExpander},
     db::ExpandDatabase,
     eager::expand_eager_macro_input,
-    files::InFileWrapper,
     impl_intern_lookup,
     name::Name,
     proc_macro::{CustomProcMacroExpander, ProcMacroKind},
@@ -521,41 +519,6 @@ pub struct FieldId {
     pub local_id: LocalFieldId,
 }
 
-impl FieldId {
-    pub fn record_field_source(
-        &self,
-        db: &dyn DefDatabase,
-    ) -> InFileWrapper<HirFileId, Option<ast::RecordField>> {
-        let field_list = match self.parent {
-            crate::VariantId::EnumVariantId(it) => {
-                let s = it.lookup(db);
-                s.source(db).map(|it| {
-                    it.field_list().and_then(|it| match it {
-                        ast::FieldList::RecordFieldList(it) => Some(it),
-                        _ => None,
-                    })
-                })
-            }
-            crate::VariantId::StructId(it) => {
-                let s = it.lookup(db);
-                s.source(db).map(|it| {
-                    it.field_list().and_then(|it| match it {
-                        ast::FieldList::RecordFieldList(it) => Some(it),
-                        _ => None,
-                    })
-                })
-            }
-            crate::VariantId::UnionId(it) => {
-                let s = it.lookup(db);
-                s.source(db).map(|it| it.record_field_list())
-            }
-        };
-        field_list.map(|it| {
-            it.and_then(|it| it.fields().nth(self.local_id.into_raw().into_u32() as usize))
-        })
-    }
-}
-
 pub type LocalFieldId = Idx<data::adt::FieldData>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -723,7 +686,6 @@ pub enum TypeOwnerId {
     TypeAliasId(TypeAliasId),
     ImplId(ImplId),
     EnumVariantId(EnumVariantId),
-    FieldId(FieldId),
 }
 
 impl TypeOwnerId {
@@ -741,11 +703,6 @@ impl TypeOwnerId {
                 GenericDefId::AdtId(AdtId::EnumId(it.lookup(db).parent))
             }
             TypeOwnerId::InTypeConstId(_) => return None,
-            TypeOwnerId::FieldId(it) => GenericDefId::AdtId(match it.parent {
-                VariantId::EnumVariantId(it) => AdtId::EnumId(it.lookup(db).parent),
-                VariantId::StructId(it) => it.into(),
-                VariantId::UnionId(it) => it.into(),
-            }),
         })
     }
 }
@@ -760,8 +717,7 @@ impl_from!(
     TraitAliasId,
     TypeAliasId,
     ImplId,
-    EnumVariantId,
-    FieldId
+    EnumVariantId
     for TypeOwnerId
 );
 
@@ -774,7 +730,6 @@ impl From<DefWithBodyId> for TypeOwnerId {
             DefWithBodyId::ConstId(it) => it.into(),
             DefWithBodyId::InTypeConstId(it) => it.into(),
             DefWithBodyId::VariantId(it) => it.into(),
-            DefWithBodyId::FieldId(it) => it.into(),
         }
     }
 }
@@ -930,7 +885,6 @@ pub enum DefWithBodyId {
     ConstId(ConstId),
     InTypeConstId(InTypeConstId),
     VariantId(EnumVariantId),
-    FieldId(FieldId),
 }
 
 impl_from!(FunctionId, ConstId, StaticId, InTypeConstId for DefWithBodyId);
@@ -951,7 +905,6 @@ impl DefWithBodyId {
             // FIXME: stable rust doesn't allow generics in constants, but we should
             // use `TypeOwnerId::as_generic_def_id` when it does.
             DefWithBodyId::InTypeConstId(_) => None,
-            DefWithBodyId::FieldId(_) => None,
         }
     }
 }
@@ -1356,12 +1309,6 @@ impl HasModule for VariantId {
     }
 }
 
-impl HasModule for FieldId {
-    fn module(&self, db: &dyn DefDatabase) -> ModuleId {
-        self.parent.module(db)
-    }
-}
-
 impl HasModule for MacroId {
     fn module(&self, db: &dyn DefDatabase) -> ModuleId {
         match *self {
@@ -1385,7 +1332,6 @@ impl HasModule for TypeOwnerId {
             TypeOwnerId::ImplId(it) => it.module(db),
             TypeOwnerId::EnumVariantId(it) => it.module(db),
             TypeOwnerId::InTypeConstId(it) => it.lookup(db).owner.module(db),
-            TypeOwnerId::FieldId(it) => it.module(db),
         }
     }
 }
@@ -1398,7 +1344,6 @@ impl HasModule for DefWithBodyId {
             DefWithBodyId::ConstId(it) => it.module(db),
             DefWithBodyId::VariantId(it) => it.module(db),
             DefWithBodyId::InTypeConstId(it) => it.lookup(db).owner.module(db),
-            DefWithBodyId::FieldId(it) => it.module(db),
         }
     }
 }