From c6509a4592b67acc4a99a7ffd6dd688bc6cd29be Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 13 Jun 2021 15:27:15 +0300 Subject: internal: move missing_fields diagnostics --- crates/hir/src/diagnostics.rs | 43 +--- crates/hir/src/lib.rs | 33 +-- crates/ide/src/diagnostics.rs | 7 +- crates/ide/src/diagnostics/fixes.rs | 1 - .../src/diagnostics/fixes/fill_missing_fields.rs | 217 ------------------- crates/ide/src/diagnostics/missing_fields.rs | 241 +++++++++++++++++++++ crates/ide/src/diagnostics/unresolved_module.rs | 5 +- 7 files changed, 268 insertions(+), 279 deletions(-) delete mode 100644 crates/ide/src/diagnostics/fixes/fill_missing_fields.rs create mode 100644 crates/ide/src/diagnostics/missing_fields.rs (limited to 'crates') diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs index 5e2f94698..a5e982b75 100644 --- a/crates/hir/src/diagnostics.rs +++ b/crates/hir/src/diagnostics.rs @@ -16,7 +16,7 @@ pub use crate::diagnostics_sink::{ }; macro_rules! diagnostics { - ($($diag:ident)*) => { + ($($diag:ident),*) => { pub enum AnyDiagnostic {$( $diag(Box<$diag>), )*} @@ -31,7 +31,7 @@ macro_rules! diagnostics { }; } -diagnostics![UnresolvedModule]; +diagnostics![UnresolvedModule, MissingFields]; #[derive(Debug)] pub struct UnresolvedModule { @@ -321,17 +321,6 @@ impl Diagnostic for MissingUnsafe { } } -// Diagnostic: missing-structure-fields -// -// This diagnostic is triggered if record lacks some fields that exist in the corresponding structure. -// -// Example: -// -// ```rust -// struct A { a: u8, b: u8 } -// -// let a = A { a: 10 }; -// ``` #[derive(Debug)] pub struct MissingFields { pub file: HirFileId, @@ -340,34 +329,6 @@ pub struct MissingFields { pub missed_fields: Vec, } -impl Diagnostic for MissingFields { - fn code(&self) -> DiagnosticCode { - DiagnosticCode("missing-structure-fields") - } - fn message(&self) -> String { - let mut buf = String::from("Missing structure fields:\n"); - for field in &self.missed_fields { - format_to!(buf, "- {}\n", field); - } - buf - } - - fn display_source(&self) -> InFile { - InFile { - file_id: self.file, - value: self - .field_list_parent_path - .clone() - .map(SyntaxNodePtr::from) - .unwrap_or_else(|| self.field_list_parent.clone().into()), - } - } - - fn as_any(&self) -> &(dyn Any + Send + 'static) { - self - } -} - // Diagnostic: missing-pat-fields // // This diagnostic is triggered if pattern lacks some fields that exist in the corresponding structure. diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs index ff6c68dbc..583d92f20 100644 --- a/crates/hir/src/lib.rs +++ b/crates/hir/src/lib.rs @@ -609,23 +609,21 @@ impl Module { } for decl in self.declarations(db) { match decl { - crate::ModuleDef::Function(f) => f.diagnostics(db, sink, internal_diagnostics), - crate::ModuleDef::Module(m) => { + ModuleDef::Function(f) => acc.extend(f.diagnostics(db, sink, internal_diagnostics)), + ModuleDef::Module(m) => { // Only add diagnostics from inline modules if def_map[m.id.local_id].origin.is_inline() { acc.extend(m.diagnostics(db, sink, internal_diagnostics)) } } - _ => { - decl.diagnostics(db, sink); - } + _ => decl.diagnostics(db, sink), } } for impl_def in self.impl_defs(db) { for item in impl_def.items(db) { if let AssocItem::Function(f) = item { - f.diagnostics(db, sink, internal_diagnostics); + acc.extend(f.diagnostics(db, sink, internal_diagnostics)); } } } @@ -1033,7 +1031,8 @@ impl Function { db: &dyn HirDatabase, sink: &mut DiagnosticSink, internal_diagnostics: bool, - ) { + ) -> Vec { + let mut acc: Vec = Vec::new(); let krate = self.module(db).id.krate(); let source_map = db.body_with_source_map(self.id.into()).1; @@ -1114,14 +1113,17 @@ impl Function { .into_iter() .map(|idx| variant_data.fields()[idx].name.clone()) .collect(); - sink.push(MissingFields { - file: source_ptr.file_id, - field_list_parent: AstPtr::new(record_expr), - field_list_parent_path: record_expr - .path() - .map(|path| AstPtr::new(&path)), - missed_fields, - }) + acc.push( + MissingFields { + file: source_ptr.file_id, + field_list_parent: AstPtr::new(record_expr), + field_list_parent_path: record_expr + .path() + .map(|path| AstPtr::new(&path)), + missed_fields, + } + .into(), + ) } } } @@ -1234,6 +1236,7 @@ impl Function { for diag in hir_ty::diagnostics::validate_module_item(db, krate, self.id.into()) { sink.push(diag) } + acc } /// Whether this function declaration has a definition. diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs index 075aae8d5..ef8c8044c 100644 --- a/crates/ide/src/diagnostics.rs +++ b/crates/ide/src/diagnostics.rs @@ -5,6 +5,7 @@ //! original files. So we need to map the ranges. mod unresolved_module; +mod missing_fields; mod fixes; mod field_shorthand; @@ -123,9 +124,6 @@ pub(crate) fn diagnostics( } let res = RefCell::new(res); let sink_builder = DiagnosticSinkBuilder::new() - .on::(|d| { - res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve)); - }) .on::(|d| { res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve)); }) @@ -232,7 +230,8 @@ pub(crate) fn diagnostics( let ctx = DiagnosticsContext { config, sema, resolve }; for diag in diags { let d = match diag { - AnyDiagnostic::UnresolvedModule(d) => unresolved_module::render(&ctx, &d), + AnyDiagnostic::UnresolvedModule(d) => unresolved_module::unresolved_module(&ctx, &d), + AnyDiagnostic::MissingFields(d) => missing_fields::missing_fields(&ctx, &d), }; if let Some(code) = d.code { if ctx.config.disabled.contains(code.as_str()) { diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs index 8640d7231..a2e792b3b 100644 --- a/crates/ide/src/diagnostics/fixes.rs +++ b/crates/ide/src/diagnostics/fixes.rs @@ -2,7 +2,6 @@ //! The same module also has all curret custom fixes for the diagnostics implemented. mod change_case; mod create_field; -mod fill_missing_fields; mod remove_semicolon; mod replace_with_find_map; mod wrap_tail_expr; diff --git a/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs b/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs deleted file mode 100644 index c76f6008a..000000000 --- a/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs +++ /dev/null @@ -1,217 +0,0 @@ -use hir::{db::AstDatabase, diagnostics::MissingFields, Semantics}; -use ide_assists::AssistResolveStrategy; -use ide_db::{source_change::SourceChange, RootDatabase}; -use syntax::{algo, ast::make, AstNode}; -use text_edit::TextEdit; - -use crate::{ - diagnostics::{fix, fixes::DiagnosticWithFixes}, - Assist, -}; - -impl DiagnosticWithFixes for MissingFields { - fn fixes( - &self, - sema: &Semantics, - _resolve: &AssistResolveStrategy, - ) -> Option> { - // Note that although we could add a diagnostics to - // fill the missing tuple field, e.g : - // `struct A(usize);` - // `let a = A { 0: () }` - // but it is uncommon usage and it should not be encouraged. - if self.missed_fields.iter().any(|it| it.as_tuple_index().is_some()) { - return None; - } - - let root = sema.db.parse_or_expand(self.file)?; - let field_list_parent = self.field_list_parent.to_node(&root); - let old_field_list = field_list_parent.record_expr_field_list()?; - let new_field_list = old_field_list.clone_for_update(); - for f in self.missed_fields.iter() { - let field = - make::record_expr_field(make::name_ref(&f.to_string()), Some(make::expr_unit())) - .clone_for_update(); - new_field_list.add_field(field); - } - - let edit = { - let mut builder = TextEdit::builder(); - algo::diff(old_field_list.syntax(), new_field_list.syntax()) - .into_text_edit(&mut builder); - builder.finish() - }; - Some(vec![fix( - "fill_missing_fields", - "Fill struct fields", - SourceChange::from_text_edit(self.file.original_file(sema.db), edit), - sema.original_range(field_list_parent.syntax()).range, - )]) - } -} - -#[cfg(test)] -mod tests { - use crate::diagnostics::tests::{check_fix, check_no_diagnostics}; - - #[test] - fn test_fill_struct_fields_empty() { - check_fix( - r#" -struct TestStruct { one: i32, two: i64 } - -fn test_fn() { - let s = TestStruct {$0}; -} -"#, - r#" -struct TestStruct { one: i32, two: i64 } - -fn test_fn() { - let s = TestStruct { one: (), two: () }; -} -"#, - ); - } - - #[test] - fn test_fill_struct_fields_self() { - check_fix( - r#" -struct TestStruct { one: i32 } - -impl TestStruct { - fn test_fn() { let s = Self {$0}; } -} -"#, - r#" -struct TestStruct { one: i32 } - -impl TestStruct { - fn test_fn() { let s = Self { one: () }; } -} -"#, - ); - } - - #[test] - fn test_fill_struct_fields_enum() { - check_fix( - r#" -enum Expr { - Bin { lhs: Box, rhs: Box } -} - -impl Expr { - fn new_bin(lhs: Box, rhs: Box) -> Expr { - Expr::Bin {$0 } - } -} -"#, - r#" -enum Expr { - Bin { lhs: Box, rhs: Box } -} - -impl Expr { - fn new_bin(lhs: Box, rhs: Box) -> Expr { - Expr::Bin { lhs: (), rhs: () } - } -} -"#, - ); - } - - #[test] - fn test_fill_struct_fields_partial() { - check_fix( - r#" -struct TestStruct { one: i32, two: i64 } - -fn test_fn() { - let s = TestStruct{ two: 2$0 }; -} -"#, - r" -struct TestStruct { one: i32, two: i64 } - -fn test_fn() { - let s = TestStruct{ two: 2, one: () }; -} -", - ); - } - - #[test] - fn test_fill_struct_fields_raw_ident() { - check_fix( - r#" -struct TestStruct { r#type: u8 } - -fn test_fn() { - TestStruct { $0 }; -} -"#, - r" -struct TestStruct { r#type: u8 } - -fn test_fn() { - TestStruct { r#type: () }; -} -", - ); - } - - #[test] - fn test_fill_struct_fields_no_diagnostic() { - check_no_diagnostics( - r#" -struct TestStruct { one: i32, two: i64 } - -fn test_fn() { - let one = 1; - let s = TestStruct{ one, two: 2 }; -} - "#, - ); - } - - #[test] - fn test_fill_struct_fields_no_diagnostic_on_spread() { - check_no_diagnostics( - r#" -struct TestStruct { one: i32, two: i64 } - -fn test_fn() { - let one = 1; - let s = TestStruct{ ..a }; -} -"#, - ); - } - - #[test] - fn test_fill_struct_fields_blank_line() { - check_fix( - r#" -struct S { a: (), b: () } - -fn f() { - S { - $0 - }; -} -"#, - r#" -struct S { a: (), b: () } - -fn f() { - S { - a: (), - b: (), - }; -} -"#, - ); - } -} diff --git a/crates/ide/src/diagnostics/missing_fields.rs b/crates/ide/src/diagnostics/missing_fields.rs new file mode 100644 index 000000000..aee780972 --- /dev/null +++ b/crates/ide/src/diagnostics/missing_fields.rs @@ -0,0 +1,241 @@ +use hir::{db::AstDatabase, InFile}; +use ide_assists::Assist; +use ide_db::source_change::SourceChange; +use stdx::format_to; +use syntax::{algo, ast::make, AstNode, SyntaxNodePtr}; +use text_edit::TextEdit; + +use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext}; + +// Diagnostic: missing-structure-fields +// +// This diagnostic is triggered if record lacks some fields that exist in the corresponding structure. +// +// Example: +// +// ```rust +// struct A { a: u8, b: u8 } +// +// let a = A { a: 10 }; +// ``` +pub(super) fn missing_fields(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Diagnostic { + let mut message = String::from("Missing structure fields:\n"); + for field in &d.missed_fields { + format_to!(message, "- {}\n", field); + } + + let ptr = InFile::new( + d.file, + d.field_list_parent_path + .clone() + .map(SyntaxNodePtr::from) + .unwrap_or_else(|| d.field_list_parent.clone().into()), + ); + + Diagnostic::new( + "missing-structure-fields", + message, + ctx.sema.diagnostics_display_range(ptr).range, + ) + .with_fixes(fixes(ctx, d)) +} + +fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option> { + // Note that although we could add a diagnostics to + // fill the missing tuple field, e.g : + // `struct A(usize);` + // `let a = A { 0: () }` + // but it is uncommon usage and it should not be encouraged. + if d.missed_fields.iter().any(|it| it.as_tuple_index().is_some()) { + return None; + } + + let root = ctx.sema.db.parse_or_expand(d.file)?; + let field_list_parent = d.field_list_parent.to_node(&root); + let old_field_list = field_list_parent.record_expr_field_list()?; + let new_field_list = old_field_list.clone_for_update(); + for f in d.missed_fields.iter() { + let field = + make::record_expr_field(make::name_ref(&f.to_string()), Some(make::expr_unit())) + .clone_for_update(); + new_field_list.add_field(field); + } + + let edit = { + let mut builder = TextEdit::builder(); + algo::diff(old_field_list.syntax(), new_field_list.syntax()).into_text_edit(&mut builder); + builder.finish() + }; + Some(vec![fix( + "fill_missing_fields", + "Fill struct fields", + SourceChange::from_text_edit(d.file.original_file(ctx.sema.db), edit), + ctx.sema.original_range(field_list_parent.syntax()).range, + )]) +} + +#[cfg(test)] +mod tests { + use crate::diagnostics::tests::{check_fix, check_no_diagnostics}; + + #[test] + fn test_fill_struct_fields_empty() { + check_fix( + r#" +struct TestStruct { one: i32, two: i64 } + +fn test_fn() { + let s = TestStruct {$0}; +} +"#, + r#" +struct TestStruct { one: i32, two: i64 } + +fn test_fn() { + let s = TestStruct { one: (), two: () }; +} +"#, + ); + } + + #[test] + fn test_fill_struct_fields_self() { + check_fix( + r#" +struct TestStruct { one: i32 } + +impl TestStruct { + fn test_fn() { let s = Self {$0}; } +} +"#, + r#" +struct TestStruct { one: i32 } + +impl TestStruct { + fn test_fn() { let s = Self { one: () }; } +} +"#, + ); + } + + #[test] + fn test_fill_struct_fields_enum() { + check_fix( + r#" +enum Expr { + Bin { lhs: Box, rhs: Box } +} + +impl Expr { + fn new_bin(lhs: Box, rhs: Box) -> Expr { + Expr::Bin {$0 } + } +} +"#, + r#" +enum Expr { + Bin { lhs: Box, rhs: Box } +} + +impl Expr { + fn new_bin(lhs: Box, rhs: Box) -> Expr { + Expr::Bin { lhs: (), rhs: () } + } +} +"#, + ); + } + + #[test] + fn test_fill_struct_fields_partial() { + check_fix( + r#" +struct TestStruct { one: i32, two: i64 } + +fn test_fn() { + let s = TestStruct{ two: 2$0 }; +} +"#, + r" +struct TestStruct { one: i32, two: i64 } + +fn test_fn() { + let s = TestStruct{ two: 2, one: () }; +} +", + ); + } + + #[test] + fn test_fill_struct_fields_raw_ident() { + check_fix( + r#" +struct TestStruct { r#type: u8 } + +fn test_fn() { + TestStruct { $0 }; +} +"#, + r" +struct TestStruct { r#type: u8 } + +fn test_fn() { + TestStruct { r#type: () }; +} +", + ); + } + + #[test] + fn test_fill_struct_fields_no_diagnostic() { + check_no_diagnostics( + r#" +struct TestStruct { one: i32, two: i64 } + +fn test_fn() { + let one = 1; + let s = TestStruct{ one, two: 2 }; +} + "#, + ); + } + + #[test] + fn test_fill_struct_fields_no_diagnostic_on_spread() { + check_no_diagnostics( + r#" +struct TestStruct { one: i32, two: i64 } + +fn test_fn() { + let one = 1; + let s = TestStruct{ ..a }; +} +"#, + ); + } + + #[test] + fn test_fill_struct_fields_blank_line() { + check_fix( + r#" +struct S { a: (), b: () } + +fn f() { + S { + $0 + }; +} +"#, + r#" +struct S { a: (), b: () } + +fn f() { + S { + a: (), + b: (), + }; +} +"#, + ); + } +} diff --git a/crates/ide/src/diagnostics/unresolved_module.rs b/crates/ide/src/diagnostics/unresolved_module.rs index abf53a57c..4c8c74ff7 100644 --- a/crates/ide/src/diagnostics/unresolved_module.rs +++ b/crates/ide/src/diagnostics/unresolved_module.rs @@ -8,7 +8,10 @@ use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext}; // Diagnostic: unresolved-module // // This diagnostic is triggered if rust-analyzer is unable to discover referred module. -pub(super) fn render(ctx: &DiagnosticsContext<'_>, d: &hir::UnresolvedModule) -> Diagnostic { +pub(super) fn unresolved_module( + ctx: &DiagnosticsContext<'_>, + d: &hir::UnresolvedModule, +) -> Diagnostic { Diagnostic::new( "unresolved-module", "unresolved module", -- cgit v1.2.3 From 6383252cc2770545505d40217732f14e93a396c4 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 13 Jun 2021 15:48:54 +0300 Subject: internal: unified missing fields diagnostic --- crates/hir/src/diagnostics.rs | 52 +----------- crates/hir/src/lib.rs | 117 ++++++++++++++------------- crates/hir_ty/src/diagnostics/expr.rs | 18 ++--- crates/ide/src/diagnostics.rs | 14 ---- crates/ide/src/diagnostics/missing_fields.rs | 35 +++++--- 5 files changed, 94 insertions(+), 142 deletions(-) (limited to 'crates') diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs index a5e982b75..158626dc0 100644 --- a/crates/hir/src/diagnostics.rs +++ b/crates/hir/src/diagnostics.rs @@ -6,6 +6,7 @@ use std::any::Any; use cfg::{CfgExpr, CfgOptions, DnfExpr}; +use either::Either; use hir_def::path::ModPath; use hir_expand::{name::Name, HirFileId, InFile}; use stdx::format_to; @@ -324,60 +325,11 @@ impl Diagnostic for MissingUnsafe { #[derive(Debug)] pub struct MissingFields { pub file: HirFileId, - pub field_list_parent: AstPtr, + pub field_list_parent: Either, AstPtr>, pub field_list_parent_path: Option>, pub missed_fields: Vec, } -// Diagnostic: missing-pat-fields -// -// This diagnostic is triggered if pattern lacks some fields that exist in the corresponding structure. -// -// Example: -// -// ```rust -// struct A { a: u8, b: u8 } -// -// let a = A { a: 10, b: 20 }; -// -// if let A { a } = a { -// // ... -// } -// ``` -#[derive(Debug)] -pub struct MissingPatFields { - pub file: HirFileId, - pub field_list_parent: AstPtr, - pub field_list_parent_path: Option>, - pub missed_fields: Vec, -} - -impl Diagnostic for MissingPatFields { - fn code(&self) -> DiagnosticCode { - DiagnosticCode("missing-pat-fields") - } - fn message(&self) -> String { - let mut buf = String::from("Missing structure fields:\n"); - for field in &self.missed_fields { - format_to!(buf, "- {}\n", field); - } - buf - } - fn display_source(&self) -> InFile { - InFile { - file_id: self.file, - value: self - .field_list_parent_path - .clone() - .map(SyntaxNodePtr::from) - .unwrap_or_else(|| self.field_list_parent.clone().into()), - } - } - fn as_any(&self) -> &(dyn Any + Send + 'static) { - self - } -} - // Diagnostic: replace-filter-map-next-with-find-map // // This diagnostic is triggered when `.filter_map(..).next()` is used, rather than the more concise `.find_map(..)`. diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs index 583d92f20..373134f62 100644 --- a/crates/hir/src/lib.rs +++ b/crates/hir/src/lib.rs @@ -88,9 +88,9 @@ pub use crate::{ diagnostics::{ AnyDiagnostic, BreakOutsideOfLoop, InactiveCode, InternalBailedOut, MacroError, MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr, - MissingPatFields, MissingUnsafe, NoSuchField, RemoveThisSemicolon, - ReplaceFilterMapNextWithFindMap, UnimplementedBuiltinMacro, UnresolvedExternCrate, - UnresolvedImport, UnresolvedMacroCall, UnresolvedModule, UnresolvedProcMacro, + MissingUnsafe, NoSuchField, RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap, + UnimplementedBuiltinMacro, UnresolvedExternCrate, UnresolvedImport, UnresolvedMacroCall, + UnresolvedModule, UnresolvedProcMacro, }, has_source::HasSource, semantics::{PathResolution, Semantics, SemanticsScope}, @@ -1098,67 +1098,70 @@ impl Function { BodyValidationDiagnostic::collect(db, self.id.into(), internal_diagnostics) { match diagnostic { - BodyValidationDiagnostic::RecordLiteralMissingFields { - record_expr, + BodyValidationDiagnostic::RecordMissingFields { + record, variant, missed_fields, - } => match source_map.expr_syntax(record_expr) { - Ok(source_ptr) => { - let root = source_ptr.file_syntax(db.upcast()); - if let ast::Expr::RecordExpr(record_expr) = &source_ptr.value.to_node(&root) - { - if let Some(_) = record_expr.record_expr_field_list() { - let variant_data = variant.variant_data(db.upcast()); - let missed_fields = missed_fields - .into_iter() - .map(|idx| variant_data.fields()[idx].name.clone()) - .collect(); - acc.push( - MissingFields { - file: source_ptr.file_id, - field_list_parent: AstPtr::new(record_expr), - field_list_parent_path: record_expr - .path() - .map(|path| AstPtr::new(&path)), - missed_fields, + } => { + let variant_data = variant.variant_data(db.upcast()); + let missed_fields = missed_fields + .into_iter() + .map(|idx| variant_data.fields()[idx].name.clone()) + .collect(); + + match record { + Either::Left(record_expr) => match source_map.expr_syntax(record_expr) { + Ok(source_ptr) => { + let root = source_ptr.file_syntax(db.upcast()); + if let ast::Expr::RecordExpr(record_expr) = + &source_ptr.value.to_node(&root) + { + if let Some(_) = record_expr.record_expr_field_list() { + acc.push( + MissingFields { + file: source_ptr.file_id, + field_list_parent: Either::Left(AstPtr::new( + record_expr, + )), + field_list_parent_path: record_expr + .path() + .map(|path| AstPtr::new(&path)), + missed_fields, + } + .into(), + ) } - .into(), - ) + } } - } - } - Err(SyntheticSyntax) => (), - }, - BodyValidationDiagnostic::RecordPatMissingFields { - record_pat, - variant, - missed_fields, - } => match source_map.pat_syntax(record_pat) { - Ok(source_ptr) => { - if let Some(expr) = source_ptr.value.as_ref().left() { - let root = source_ptr.file_syntax(db.upcast()); - if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) { - if let Some(_) = record_pat.record_pat_field_list() { - let variant_data = variant.variant_data(db.upcast()); - let missed_fields = missed_fields - .into_iter() - .map(|idx| variant_data.fields()[idx].name.clone()) - .collect(); - sink.push(MissingPatFields { - file: source_ptr.file_id, - field_list_parent: AstPtr::new(&record_pat), - field_list_parent_path: record_pat - .path() - .map(|path| AstPtr::new(&path)), - missed_fields, - }) + Err(SyntheticSyntax) => (), + }, + Either::Right(record_pat) => match source_map.pat_syntax(record_pat) { + Ok(source_ptr) => { + if let Some(expr) = source_ptr.value.as_ref().left() { + let root = source_ptr.file_syntax(db.upcast()); + if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) { + if let Some(_) = record_pat.record_pat_field_list() { + acc.push( + MissingFields { + file: source_ptr.file_id, + field_list_parent: Either::Right(AstPtr::new( + &record_pat, + )), + field_list_parent_path: record_pat + .path() + .map(|path| AstPtr::new(&path)), + missed_fields, + } + .into(), + ) + } + } } } - } + Err(SyntheticSyntax) => (), + }, } - Err(SyntheticSyntax) => (), - }, - + } BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap { method_call_expr } => { if let Ok(next_source_ptr) = source_map.expr_syntax(method_call_expr) { sink.push(ReplaceFilterMapNextWithFindMap { diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs index c480ed352..2a211fd8e 100644 --- a/crates/hir_ty/src/diagnostics/expr.rs +++ b/crates/hir_ty/src/diagnostics/expr.rs @@ -8,6 +8,7 @@ use hir_def::{ expr::Statement, path::path, resolver::HasResolver, AssocItemId, DefWithBodyId, HasModule, }; use hir_expand::name; +use itertools::Either; use rustc_hash::FxHashSet; use crate::{ @@ -26,13 +27,8 @@ pub(crate) use hir_def::{ }; pub enum BodyValidationDiagnostic { - RecordLiteralMissingFields { - record_expr: ExprId, - variant: VariantId, - missed_fields: Vec, - }, - RecordPatMissingFields { - record_pat: PatId, + RecordMissingFields { + record: Either, variant: VariantId, missed_fields: Vec, }, @@ -95,8 +91,8 @@ impl ExprValidator { if let Some((variant, missed_fields, true)) = record_literal_missing_fields(db, &self.infer, id, expr) { - self.diagnostics.push(BodyValidationDiagnostic::RecordLiteralMissingFields { - record_expr: id, + self.diagnostics.push(BodyValidationDiagnostic::RecordMissingFields { + record: Either::Left(id), variant, missed_fields, }); @@ -116,8 +112,8 @@ impl ExprValidator { if let Some((variant, missed_fields, true)) = record_pattern_missing_fields(db, &self.infer, id, pat) { - self.diagnostics.push(BodyValidationDiagnostic::RecordPatMissingFields { - record_pat: id, + self.diagnostics.push(BodyValidationDiagnostic::RecordMissingFields { + record: Either::Right(id), variant, missed_fields, }); diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs index ef8c8044c..3307e240b 100644 --- a/crates/ide/src/diagnostics.rs +++ b/crates/ide/src/diagnostics.rs @@ -1055,20 +1055,6 @@ fn main() { )); } - #[test] - fn missing_record_pat_field_diagnostic() { - check_diagnostics( - r#" -struct S { foo: i32, bar: () } -fn baz(s: S) { - let S { foo: _ } = s; - //^ Missing structure fields: - //| - bar -} -"#, - ); - } - #[test] fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() { check_diagnostics( diff --git a/crates/ide/src/diagnostics/missing_fields.rs b/crates/ide/src/diagnostics/missing_fields.rs index aee780972..66575f713 100644 --- a/crates/ide/src/diagnostics/missing_fields.rs +++ b/crates/ide/src/diagnostics/missing_fields.rs @@ -1,3 +1,4 @@ +use either::Either; use hir::{db::AstDatabase, InFile}; use ide_assists::Assist; use ide_db::source_change::SourceChange; @@ -7,7 +8,7 @@ use text_edit::TextEdit; use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext}; -// Diagnostic: missing-structure-fields +// Diagnostic: missing-fields // // This diagnostic is triggered if record lacks some fields that exist in the corresponding structure. // @@ -29,15 +30,11 @@ pub(super) fn missing_fields(ctx: &DiagnosticsContext<'_>, d: &hir::MissingField d.field_list_parent_path .clone() .map(SyntaxNodePtr::from) - .unwrap_or_else(|| d.field_list_parent.clone().into()), + .unwrap_or_else(|| d.field_list_parent.clone().either(|it| it.into(), |it| it.into())), ); - Diagnostic::new( - "missing-structure-fields", - message, - ctx.sema.diagnostics_display_range(ptr).range, - ) - .with_fixes(fixes(ctx, d)) + Diagnostic::new("missing-fields", message, ctx.sema.diagnostics_display_range(ptr).range) + .with_fixes(fixes(ctx, d)) } fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option> { @@ -51,7 +48,11 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option record_expr.to_node(&root), + // FIXE: patterns should be fixable as well. + Either::Right(_) => return None, + }; let old_field_list = field_list_parent.record_expr_field_list()?; let new_field_list = old_field_list.clone_for_update(); for f in d.missed_fields.iter() { @@ -76,7 +77,21 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option