Add support for chaning ref argument definition to mutable

Author: wawel37

src/ide/code_actions/make_variable_mutable.rs

@@ -21,32 +21,52 @@ pub fn make_variable_mutable<'db>(
 
         let identifier =
             token.ancestors_with_self(db).find_map(|node| TerminalIdentifier::cast(db, node))?;
-        let definition_location = SymbolSearch::find_definition(db, &identifier)?
-            .def
-            .definition_originating_location(db)?;
-        let definition = db.find_syntax_node_at_offset(
-            definition_location.file_id,
-            definition_location.span.start,
-        )?;
-
-        let span_to_edit = definition
-            .span_without_trivia(db)
-            .position_in_file(db, definition.stable_ptr(db).file_id(db))?;
-
-        let edits = vec![TextEdit {
-            range: span_to_edit.to_lsp(),
-            new_text: format!("mut {}", definition.get_text_without_trivia(db).to_string(db)),
-        }];
-
-        Some(CodeAction {
-            title: "Change it to be mutable".to_string(),
-            kind: Some(CodeActionKind::QUICKFIX),
-            edit: Some(WorkspaceEdit {
-                changes: Some(HashMap::from([(uri.clone(), edits)])),
-                document_changes: None,
-                change_annotations: None,
-            }),
-            ..Default::default()
-        })
+        get_mutable_variable_action(db, identifier, uri.clone())
+    })
+}
+
+pub fn make_ref_variable_mutable<'db>(
+    db: &'db AnalysisDatabase,
+    node: SyntaxNode<'db>,
+    uri: Url,
+) -> Option<CodeAction> {
+    db.get_node_resultants(node)?.iter().find_map(|resultant_node| {
+        let identifier = resultant_node
+            .ancestors_with_self(db)
+            .find_map(|node| TerminalIdentifier::cast(db, node))?;
+        get_mutable_variable_action(db, identifier, uri.clone())
+    })
+}
+
+fn get_mutable_variable_action<'db>(
+    db: &'db AnalysisDatabase,
+    identifier: TerminalIdentifier<'db>,
+    uri: Url,
+) -> Option<CodeAction> {
+    let definition_location =
+        SymbolSearch::find_definition(db, &identifier)?.def.definition_originating_location(db)?;
+    let definition =
+        db.find_syntax_node_at_offset(definition_location.file_id, definition_location.span.start)?;
+
+    let span_to_edit =
+        definition.span_without_trivia(db).position_in_file(db, definition.file_id(db))?;
+
+    let edits = vec![TextEdit {
+        range: span_to_edit.to_lsp(),
+        new_text: format!("mut {}", definition.get_text_without_trivia(db).to_string(db)),
+    }];
+
+    Some(CodeAction {
+        title: format!(
+            "Change \"{}\" to be mutable",
+            definition.get_text_without_trivia(db).to_string(db)
+        ),
+        kind: Some(CodeActionKind::QUICKFIX),
+        edit: Some(WorkspaceEdit {
+            changes: Some(HashMap::from([(uri.clone(), edits)])),
+            document_changes: None,
+            change_annotations: None,
+        }),
+        ..Default::default()
     })
 }

src/ide/code_actions/mod.rs

@@ -124,6 +124,9 @@ fn get_code_actions_for_diagnostics(
             Some("E2083") => {
                 make_variable_mutable::make_variable_mutable(db, ctx.node, uri.clone()).to_vec()
             }
+            Some("E2080") => {
+                make_variable_mutable::make_ref_variable_mutable(db, ctx.node, uri.clone()).to_vec()
+            }
             Some(code) => {
                 debug!("no code actions for diagnostic code: {code}");
                 vec![]

tests/e2e/code_actions/make_variable_mutable.rs

@@ -9,7 +9,7 @@ fn change_to_mutable_let_definition() {
         a = 25<caret>;
     }
     ", @r#"
-    Title: Change it to be mutable
+    Title: Change "a" to be mutable
     Add new text: "mut a"
     At: Range { start: Position { line: 1, character: 8 }, end: Position { line: 1, character: 9 } }
     "#);
@@ -22,7 +22,7 @@ fn change_to_mutable_param_definition() {
         a = 25<caret>;
     }
     ", @r#"
-    Title: Change it to be mutable
+    Title: Change "a" to be mutable
     Add new text: "mut a"
     At: Range { start: Position { line: 0, character: 7 }, end: Position { line: 0, character: 8 } }
     "#);
@@ -37,7 +37,7 @@ fn change_to_mutable_let_definition_with_macros() {
         a = 25<caret>;
     }
     ", @r#"
-    Title: Change it to be mutable
+    Title: Change "a" to be mutable
     Add new text: "mut a"
     At: Range { start: Position { line: 2, character: 8 }, end: Position { line: 2, character: 9 } }
     "#);
@@ -51,8 +51,67 @@ fn change_to_mutable_param_definition_with_macros() {
         a = 25<caret>;
     }
     ", @r#"
-    Title: Change it to be mutable
+    Title: Change "a" to be mutable
     Add new text: "mut a"
     At: Range { start: Position { line: 1, character: 7 }, end: Position { line: 1, character: 8 } }
     "#);
 }
+
+#[test]
+fn change_ref_argument_to_mutable() {
+    test_transform!(quick_fix, "
+    #[derive(Copy, Drop)]
+    struct X {}
+
+    trait Abc {
+        fn abc(self: X, ref a: felt252) {}
+    }
+
+
+    impl AbcImpl of Abc {
+        fn abc(self: X, ref a: felt252) {
+            a = 5;
+        }
+    }
+
+    fn main() {
+        let x = X {};
+        let a = 15;
+        x.abc(ref a<caret>);
+    }
+    ", @r#"
+    Title: Change "a" to be mutable
+    Add new text: "mut a"
+    At: Range { start: Position { line: 16, character: 8 }, end: Position { line: 16, character: 9 } }
+    "#);
+}
+
+#[test]
+fn change_ref_argument_to_mutable_with_macros() {
+    test_transform!(quick_fix_with_macros, "
+    #[derive(Copy, Drop)]
+    struct X {}
+
+    trait Abc {
+        fn abc(self: X, ref a: felt252) {}
+    }
+
+
+    impl AbcImpl of Abc {
+        fn abc(self: X, ref a: felt252) {
+            a = 5;
+        }
+    }
+
+    #[test]
+    fn maintest() {
+        let x = X {};
+        let a = 15;
+        x.abc(ref a<caret>);
+    }
+    ", @r#"
+    Title: Change "a" to be mutable
+    Add new text: "mut a"
+    At: Range { start: Position { line: 17, character: 8 }, end: Position { line: 17, character: 9 } }
+    "#);
+}