Merge #5595

5595: Rename RecordLit -> RecordExpr r=matklad a=matklad



bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

crates/ra_assists/src/handlers/change_return_type_to_result.rs

@@ -240,7 +240,7 @@ fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
         Expr::ParenExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::PathExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::Label(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
-        Expr::RecordLit(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::RecordExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::IndexExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::MethodCallExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::AwaitExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),

crates/ra_assists/src/handlers/extract_variable.rs

@@ -45,7 +45,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
         target,
         move |edit| {
             let field_shorthand =
-                match to_extract.syntax().parent().and_then(ast::RecordField::cast) {
+                match to_extract.syntax().parent().and_then(ast::RecordExprField::cast) {
                     Some(field) => field.name_ref(),
                     None => None,
                 };

crates/ra_assists/src/handlers/fix_visibility.rs

@@ -82,7 +82,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::RecordField = ctx.find_node_at_offset()?;
+    let record_field: ast::RecordExprField = ctx.find_node_at_offset()?;
     let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
 
     let current_module = ctx.sema.scope(record_field.syntax()).module()?;

crates/ra_assists/src/handlers/reorder_fields.rs

@@ -23,7 +23,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 //
 pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    reorder::<ast::RecordLit>(acc, ctx).or_else(|| reorder::<ast::RecordPat>(acc, ctx))
+    reorder::<ast::RecordExpr>(acc, ctx).or_else(|| reorder::<ast::RecordPat>(acc, ctx))
 }
 
 fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
@@ -56,7 +56,7 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 
 fn get_fields_kind(node: &SyntaxNode) -> Vec<SyntaxKind> {
     match node.kind() {
-        RECORD_LIT => vec![RECORD_FIELD],
+        RECORD_EXPR => vec![RECORD_EXPR_FIELD],
         RECORD_PAT => vec![RECORD_FIELD_PAT, BIND_PAT],
         _ => vec![],
     }
@@ -65,7 +65,7 @@ fn get_fields_kind(node: &SyntaxNode) -> Vec<SyntaxKind> {
 fn get_field_name(node: &SyntaxNode) -> String {
     let res = match_ast! {
         match node {
-            ast::RecordField(field) => field.field_name().map(|it| it.to_string()),
+            ast::RecordExprField(field) => field.field_name().map(|it| it.to_string()),
             ast::RecordFieldPat(field) => field.field_name().map(|it| it.to_string()),
             _ => None,
         }

crates/ra_hir/src/semantics.rs

@@ -209,7 +209,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.imp.resolve_field(field)
     }
 
-    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
+    pub fn resolve_record_field(
+        &self,
+        field: &ast::RecordExprField,
+    ) -> Option<(Field, Option<Local>)> {
         self.imp.resolve_record_field(field)
     }
 
@@ -225,7 +228,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.imp.resolve_path(path)
     }
 
-    pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantDef> {
+    pub fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantDef> {
         self.imp.resolve_variant(record_lit).map(VariantDef::from)
     }
 
@@ -240,7 +243,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
     // FIXME: use this instead?
     // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
 
-    pub fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
+    pub fn record_literal_missing_fields(&self, literal: &ast::RecordExpr) -> Vec<(Field, Type)> {
         self.imp.record_literal_missing_fields(literal)
     }
 
@@ -422,7 +425,7 @@ impl<'db> SemanticsImpl<'db> {
         self.analyze(field.syntax()).resolve_field(self.db, field)
     }
 
-    fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
+    fn resolve_record_field(&self, field: &ast::RecordExprField) -> Option<(Field, Option<Local>)> {
         self.analyze(field.syntax()).resolve_record_field(self.db, field)
     }
 
@@ -440,7 +443,7 @@ impl<'db> SemanticsImpl<'db> {
         self.analyze(path.syntax()).resolve_path(self.db, path)
     }
 
-    fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantId> {
+    fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantId> {
         self.analyze(record_lit.syntax()).resolve_variant(self.db, record_lit)
     }
 
@@ -453,7 +456,7 @@ impl<'db> SemanticsImpl<'db> {
         self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
     }
 
-    fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
+    fn record_literal_missing_fields(&self, literal: &ast::RecordExpr) -> Vec<(Field, Type)> {
         self.analyze(literal.syntax())
             .record_literal_missing_fields(self.db, literal)
             .unwrap_or_default()

crates/ra_hir/src/source_analyzer.rs

@@ -159,7 +159,7 @@ impl SourceAnalyzer {
     pub(crate) fn resolve_record_field(
         &self,
         db: &dyn HirDatabase,
-        field: &ast::RecordField,
+        field: &ast::RecordExprField,
     ) -> Option<(Field, Option<Local>)> {
         let expr = field.expr()?;
         let expr_id = self.expr_id(db, &expr)?;
@@ -246,7 +246,7 @@ impl SourceAnalyzer {
             }
         }
 
-        if let Some(rec_lit) = path.syntax().parent().and_then(ast::RecordLit::cast) {
+        if let Some(rec_lit) = path.syntax().parent().and_then(ast::RecordExpr::cast) {
             let expr_id = self.expr_id(db, &rec_lit.into())?;
             if let Some(VariantId::EnumVariantId(variant)) =
                 self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
@@ -284,7 +284,7 @@ impl SourceAnalyzer {
     pub(crate) fn record_literal_missing_fields(
         &self,
         db: &dyn HirDatabase,
-        literal: &ast::RecordLit,
+        literal: &ast::RecordExpr,
     ) -> Option<Vec<(Field, Type)>> {
         let krate = self.resolver.krate()?;
         let body = self.body.as_ref()?;
@@ -358,7 +358,7 @@ impl SourceAnalyzer {
     pub(crate) fn resolve_variant(
         &self,
         db: &dyn HirDatabase,
-        record_lit: ast::RecordLit,
+        record_lit: ast::RecordExpr,
     ) -> Option<VariantId> {
         let infer = self.infer.as_ref()?;
         let expr_id = self.expr_id(db, &record_lit.into())?;

crates/ra_hir_def/src/body.rs

@@ -216,7 +216,7 @@ pub struct BodySourceMap {
     expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
     pat_map: FxHashMap<PatSource, PatId>,
     pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
-    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordField>>>,
+    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
     expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
 }
 
@@ -314,7 +314,7 @@ impl BodySourceMap {
         self.pat_map.get(&src).cloned()
     }
 
-    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordField>> {
+    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
         self.field_map[&(expr, field)].clone()
     }
 }

crates/ra_hir_def/src/body/lower.rs

@@ -379,10 +379,10 @@ impl ExprCollector<'_> {
                 let expr = e.expr().map(|e| self.collect_expr(e));
                 self.alloc_expr(Expr::Return { expr }, syntax_ptr)
             }
-            ast::Expr::RecordLit(e) => {
+            ast::Expr::RecordExpr(e) => {
                 let path = e.path().and_then(|path| self.expander.parse_path(path));
                 let mut field_ptrs = Vec::new();
-                let record_lit = if let Some(nfl) = e.record_field_list() {
+                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
                     let fields = nfl
                         .fields()
                         .inspect(|field| field_ptrs.push(AstPtr::new(field)))

crates/ra_hir_expand/src/db.rs

@@ -386,7 +386,7 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
         MATCH_EXPR => FragmentKind::Expr,
         MATCH_ARM => FragmentKind::Expr,
         MATCH_GUARD => FragmentKind::Expr,
-        RECORD_FIELD => FragmentKind::Expr,
+        RECORD_EXPR_FIELD => FragmentKind::Expr,
         CALL_EXPR => FragmentKind::Expr,
         INDEX_EXPR => FragmentKind::Expr,
         METHOD_CALL_EXPR => FragmentKind::Expr,

crates/ra_hir_ty/src/diagnostics.rs

@@ -29,7 +29,7 @@ pub fn validate_body(db: &dyn HirDatabase, owner: DefWithBodyId, sink: &mut Diag
 #[derive(Debug)]
 pub struct NoSuchField {
     pub file: HirFileId,
-    pub field: AstPtr<ast::RecordField>,
+    pub field: AstPtr<ast::RecordExprField>,
 }
 
 impl Diagnostic for NoSuchField {
@@ -47,19 +47,19 @@ impl Diagnostic for NoSuchField {
 }
 
 impl AstDiagnostic for NoSuchField {
-    type AST = ast::RecordField;
+    type AST = ast::RecordExprField;
 
     fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
         let root = db.parse_or_expand(self.source().file_id).unwrap();
         let node = self.source().value.to_node(&root);
-        ast::RecordField::cast(node).unwrap()
+        ast::RecordExprField::cast(node).unwrap()
     }
 }
 
 #[derive(Debug)]
 pub struct MissingFields {
     pub file: HirFileId,
-    pub field_list: AstPtr<ast::RecordFieldList>,
+    pub field_list: AstPtr<ast::RecordExprFieldList>,
     pub missed_fields: Vec<Name>,
 }
 
@@ -80,12 +80,12 @@ impl Diagnostic for MissingFields {
 }
 
 impl AstDiagnostic for MissingFields {
-    type AST = ast::RecordFieldList;
+    type AST = ast::RecordExprFieldList;
 
     fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
         let root = db.parse_or_expand(self.source().file_id).unwrap();
         let node = self.source().value.to_node(&root);
-        ast::RecordFieldList::cast(node).unwrap()
+        ast::RecordExprFieldList::cast(node).unwrap()
     }
 }