Add a quickfix for accessing a private field of a struct

Author: MatrixFrog

crates/ide-diagnostics/src/handlers/no_such_field.rs

@@ -4,7 +4,7 @@ use ide_db::text_edit::TextEdit;
 use ide_db::{EditionedFileId, RootDatabase, source_change::SourceChange};
 use syntax::{
     AstNode,
-    ast::{self, edit::IndentLevel, make},
+    ast::{self, HasName, RecordField, RecordFieldList, edit::IndentLevel, make},
 };
 
 use crate::{Assist, Diagnostic, DiagnosticCode, DiagnosticsContext, fix};
@@ -23,6 +23,7 @@ pub(crate) fn no_such_field(ctx: &DiagnosticsContext<'_>, d: &hir::NoSuchField)
             node,
         )
         .stable()
+        .with_fixes(field_is_private_fixes(ctx, d))
     } else {
         Diagnostic::new_with_syntax_node_ptr(
             ctx,
@@ -34,11 +35,87 @@ pub(crate) fn no_such_field(ctx: &DiagnosticsContext<'_>, d: &hir::NoSuchField)
             node,
         )
         .stable()
-        .with_fixes(fixes(ctx, d))
+        .with_fixes(no_such_field_fixes(ctx, d))
     }
 }
 
-fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::NoSuchField) -> Option<Vec<Assist>> {
+fn field_is_private_fixes(
+    ctx: &DiagnosticsContext<'_>,
+    d: &hir::NoSuchField,
+) -> Option<Vec<Assist>> {
+    let root = ctx.sema.db.parse_or_expand(d.field.file_id);
+    match &d.field.value.to_node(&root) {
+        Either::Left(node) => private_record_expr_field_fixes(
+            &ctx.sema,
+            d.field.file_id.original_file(ctx.sema.db),
+            node,
+        ),
+        _ => None,
+    }
+}
+fn private_record_expr_field_fixes(
+    sema: &Semantics<'_, RootDatabase>,
+    usage_file_id: EditionedFileId,
+    record_expr_field: &ast::RecordExprField,
+) -> Option<Vec<Assist>> {
+    let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?;
+    let def_id = sema.resolve_variant(record_lit)?;
+    let module;
+    let def_file_id;
+    let record_fields = match def_id {
+        hir::VariantDef::Struct(s) => {
+            module = s.module(sema.db);
+            let source = s.source(sema.db)?;
+            def_file_id = source.file_id;
+            let fields = source.value.field_list()?;
+            record_field_list(fields)?
+        }
+        hir::VariantDef::Union(u) => {
+            module = u.module(sema.db);
+            let source = u.source(sema.db)?;
+            def_file_id = source.file_id;
+            source.value.record_field_list()?
+        }
+        hir::VariantDef::Variant(e) => {
+            module = e.module(sema.db);
+            let source = e.source(sema.db)?;
+            def_file_id = source.file_id;
+            let fields = source.value.field_list()?;
+            record_field_list(fields)?
+        }
+    };
+    let def_file_id = def_file_id.original_file(sema.db);
+
+    let field_definition = find_field(&record_fields, record_expr_field)?;
+
+    let source_change = SourceChange::from_text_edit(
+        def_file_id.file_id(sema.db),
+        TextEdit::insert(field_definition.syntax().text_range().start(), "pub ".into()),
+    );
+
+    return Some(vec![fix(
+        "make_field_public",
+        "Make field public",
+        source_change,
+        record_expr_field.syntax().text_range(),
+    )]);
+}
+
+fn find_field(
+    field_list: &RecordFieldList,
+    record_expr_field: &ast::RecordExprField,
+) -> Option<RecordField> {
+    for field in field_list.fields() {
+        let name = field.name()?;
+        let token = name.ident_token()?;
+        if token.text() == record_expr_field.field_name()?.ident_token()?.text() {
+            return Some(field);
+        }
+    }
+    None
+}
+
+fn no_such_field_fixes(ctx: &DiagnosticsContext<'_>, d: &hir::NoSuchField) -> Option<Vec<Assist>> {
     // FIXME: quickfix for pattern
     let root = ctx.sema.db.parse_or_expand(d.field.file_id);
     match &d.field.value.to_node(&root) {
@@ -120,12 +197,11 @@ fn missing_record_expr_field_fixes(
         source_change,
         record_expr_field.syntax().text_range(),
     )]);
-
-    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
-        match field_def_list {
-            ast::FieldList::RecordFieldList(it) => Some(it),
-            ast::FieldList::TupleFieldList(_) => None,
-        }
+}
+fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
+    match field_def_list {
+        ast::FieldList::RecordFieldList(it) => Some(it),
+        ast::FieldList::TupleFieldList(_) => None,
     }
 }
 
@@ -368,6 +444,52 @@ fn main() {
         )
     }
 
+    #[test]
+    fn test_struct_field_private_fix() {
+        check_diagnostics(
+            r#"
+mod m {
+    pub struct Struct {
+        field: u32,
+    }
+}
+fn f() {
+    let _ = m::Struct {
+        field: 0,
+      //^^^^^^^^ 💡 error: field is private
+    };
+}
+"#,
+        );
+
+        check_fix(
+            r#"
+mod m {
+    pub struct Struct {
+        field: u32,
+    }
+}
+fn f() {
+    let _ = m::Struct {
+        field$0: 0,
+    };
+}
+"#,
+            r#"
+mod m {
+    pub struct Struct {
+        pub field: u32,
+    }
+}
+fn f() {
+    let _ = m::Struct {
+        field: 0,
+    };
+}
+"#,
+        )
+    }
+
     #[test]
     fn test_struct_field_private() {
         check_diagnostics(