Merge pull request #19001 from ShoyuVanilla/default-field-values

feat: Implement `default-field-values`

Author: Veykril

crates/hir-def/src/data/adt.rs

@@ -85,6 +85,7 @@ pub struct FieldData {
     pub name: Name,
     pub type_ref: TypeRefId,
     pub visibility: RawVisibility,
+    pub has_default: bool,
 }
 
 fn repr_from_value(
@@ -478,5 +479,6 @@ 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,
     }
 }

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, Statement,
+        PatId, RecordFieldPat, Spread, Statement,
     },
     nameres::DefMap,
     path::{ModPath, Path},
@@ -362,7 +362,7 @@ impl ExpressionStore {
                 for field in fields.iter() {
                     f(field.expr);
                 }
-                if let &Some(expr) = spread {
+                if let &Spread::Base(expr) = spread {
                     f(expr);
                 }
             }
@@ -490,7 +490,7 @@ impl ExpressionStore {
                 for field in fields.iter() {
                     f(field.expr);
                 }
-                if let &Some(expr) = spread {
+                if let &Spread::Base(expr) = spread {
                     f(expr);
                 }
             }

crates/hir-def/src/expr_store/body.rs

@@ -122,6 +122,9 @@ 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);

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, Statement,
+        OffsetOf, Pat, PatId, RecordFieldPat, RecordLitField, Spread, Statement,
     },
     item_scope::BuiltinShadowMode,
     lang_item::LangItem,
@@ -90,6 +90,7 @@ 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]);
@@ -168,6 +169,7 @@ pub(super) fn lower_body(
                     Awaitable::No("constant")
                 }
                 DefWithBodyId::VariantId(..) => Awaitable::No("enum variant"),
+                DefWithBodyId::FieldId(..) => Awaitable::No("field"),
             }
         },
     );
@@ -600,10 +602,13 @@ impl ExprCollector<'_> {
                             Some(RecordLitField { name, expr })
                         })
                         .collect();
-                    let spread = nfl.spread().map(|s| self.collect_expr(s));
+                    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,
+                    );
                     Expr::RecordLit { path, fields, spread }
                 } else {
-                    Expr::RecordLit { path, fields: Box::default(), spread: None }
+                    Expr::RecordLit { path, fields: Box::default(), spread: Spread::No }
                 };
 
                 self.alloc_expr(record_lit, syntax_ptr)

crates/hir-def/src/expr_store/pretty.rs

@@ -8,9 +8,10 @@ use span::Edition;
 use crate::{
     hir::{
         Array, BindingAnnotation, CaptureBy, ClosureKind, Literal, LiteralOrConst, Movability,
-        Statement,
+        Spread, Statement,
     },
     pretty::{print_generic_args, print_path, print_type_ref},
+    VariantId,
 };
 
 use super::*;
@@ -56,6 +57,32 @@ 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 {
@@ -385,10 +412,16 @@ impl Printer<'_> {
                         p.print_expr(field.expr);
                         wln!(p, ",");
                     }
-                    if let Some(spread) = spread {
-                        w!(p, "..");
-                        p.print_expr(*spread);
-                        wln!(p);
+                    match spread {
+                        Spread::No => {}
+                        Spread::Yes => {
+                            w!(p, "..");
+                        }
+                        Spread::Base(expr) => {
+                            w!(p, "..");
+                            p.print_expr(*expr);
+                            wln!(p);
+                        }
                     }
                 });
                 w!(self, "}}");

crates/hir-def/src/hir.rs

@@ -251,7 +251,7 @@ pub enum Expr {
     RecordLit {
         path: Option<Box<Path>>,
         fields: Box<[RecordLitField]>,
-        spread: Option<ExprId>,
+        spread: Spread,
     },
     Field {
         expr: ExprId,
@@ -478,6 +478,13 @@ 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 {

crates/hir-def/src/item_tree.rs

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

crates/hir-def/src/item_tree/lower.rs

@@ -319,8 +319,9 @@ 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 }
+        Field { name, type_ref, visibility, has_default }
     }
 
     fn lower_tuple_field(
@@ -332,7 +333,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 }
+        Field { name, type_ref, visibility, has_default: false }
     }
 
     fn lower_union(&mut self, union: &ast::Union) -> Option<FileItemTreeId<Union>> {

crates/hir-def/src/item_tree/pretty.rs

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

crates/hir-def/src/lib.rs

@@ -55,6 +55,7 @@ pub mod visibility;
 
 use intern::Interned;
 pub use rustc_abi as layout;
+use src::HasSource;
 use triomphe::Arc;
 
 #[cfg(test)]
@@ -77,6 +78,7 @@ 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},
@@ -519,6 +521,41 @@ 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)]
@@ -686,6 +723,7 @@ pub enum TypeOwnerId {
     TypeAliasId(TypeAliasId),
     ImplId(ImplId),
     EnumVariantId(EnumVariantId),
+    FieldId(FieldId),
 }
 
 impl TypeOwnerId {
@@ -703,6 +741,11 @@ 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(),
+            }),
         })
     }
 }
@@ -717,7 +760,8 @@ impl_from!(
     TraitAliasId,
     TypeAliasId,
     ImplId,
-    EnumVariantId
+    EnumVariantId,
+    FieldId
     for TypeOwnerId
 );
 
@@ -730,6 +774,7 @@ 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(),
         }
     }
 }
@@ -885,6 +930,7 @@ pub enum DefWithBodyId {
     ConstId(ConstId),
     InTypeConstId(InTypeConstId),
     VariantId(EnumVariantId),
+    FieldId(FieldId),
 }
 
 impl_from!(FunctionId, ConstId, StaticId, InTypeConstId for DefWithBodyId);
@@ -905,6 +951,7 @@ 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,
         }
     }
 }
@@ -1309,6 +1356,12 @@ 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 {
@@ -1332,6 +1385,7 @@ 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),
         }
     }
 }
@@ -1344,6 +1398,7 @@ 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),
         }
     }
 }