add code action to remove opaque from private types

Author: giacomocavalieri

CHANGELOG.md

@@ -75,6 +75,27 @@
 
 ### Language server
 
+- The language server now offers a quick fix to remove `opaque` from a private
+  type:
+
+  ```gleam
+  opaque type Wibble {
+  // ^^^ This is an error!
+    Wobble
+  }
+  ```
+
+  If you hover over the type and trigger the quick fix, the language server will
+  automatically remove the `opaque` keyword:
+
+  ```gleam
+  type Wibble {
+    Wobble
+  }
+  ```
+
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 ### Formatter
 
 ### Bug fixes

compiler-core/src/language_server/code_action.rs

@@ -7490,3 +7490,75 @@ impl<'ast> ast::visit::Visit<'ast> for RemoveBlock<'ast> {
         ast::visit::visit_typed_expr_block(self, location, statements);
     }
 }
+
+/// Code action to remove `opaque` from a private type.
+///
+pub struct RemovePrivateOpaque<'a> {
+    module: &'a Module,
+    params: &'a CodeActionParams,
+    edits: TextEdits<'a>,
+    opaque_span: Option<SrcSpan>,
+}
+
+impl<'a> RemovePrivateOpaque<'a> {
+    pub fn new(
+        module: &'a Module,
+        line_numbers: &'a LineNumbers,
+        params: &'a CodeActionParams,
+    ) -> Self {
+        Self {
+            module,
+            params,
+            edits: TextEdits::new(line_numbers),
+            opaque_span: None,
+        }
+    }
+
+    pub fn code_actions(mut self) -> Vec<CodeAction> {
+        self.visit_typed_module(&self.module.ast);
+
+        let Some(opaque_span) = self.opaque_span else {
+            return vec![];
+        };
+
+        self.edits.delete(opaque_span);
+
+        let mut action = Vec::with_capacity(1);
+        CodeActionBuilder::new("Remove opaque from private type")
+            .kind(CodeActionKind::QUICKFIX)
+            .changes(self.params.text_document.uri.clone(), self.edits.edits)
+            .preferred(true)
+            .push_to(&mut action);
+        action
+    }
+}
+
+impl<'ast> ast::visit::Visit<'ast> for RemovePrivateOpaque<'ast> {
+    fn visit_typed_definition(&mut self, def: &'ast ast::TypedDefinition) {
+        // This code action is only relevant for type definitions, so we don't
+        // waste any time visiting definitions that are not relevant.
+        match def {
+            ast::Definition::Function(_)
+            | ast::Definition::TypeAlias(_)
+            | ast::Definition::Import(_)
+            | ast::Definition::ModuleConstant(_) => (),
+            ast::Definition::CustomType(custom_type) => {
+                self.visit_typed_custom_type(custom_type);
+            }
+        }
+    }
+
+    fn visit_typed_custom_type(&mut self, custom_type: &'ast ast::TypedCustomType) {
+        let custom_type_range = self.edits.src_span_to_lsp_range(custom_type.location);
+        if !within(self.params.range, custom_type_range) {
+            return;
+        }
+
+        if custom_type.opaque && custom_type.publicity.is_private() {
+            self.opaque_span = Some(SrcSpan {
+                start: custom_type.location.start,
+                end: custom_type.location.start + 7,
+            })
+        }
+    }
+}

compiler-core/src/language_server/engine.rs

@@ -12,7 +12,9 @@ use crate::{
     config::PackageConfig,
     io::{BeamCompiler, CommandExecutor, FileSystemReader, FileSystemWriter},
     language_server::{
-        code_action::RemoveBlock, compiler::LspProjectCompiler, files::FileSystemProxy,
+        code_action::{RemoveBlock, RemovePrivateOpaque},
+        compiler::LspProjectCompiler,
+        files::FileSystemProxy,
         progress::ProgressReporter,
     },
     line_numbers::LineNumbers,
@@ -437,6 +439,7 @@ where
             actions.extend(InlineVariable::new(module, &lines, &params).code_actions());
             actions.extend(WrapInBlock::new(module, &lines, &params).code_actions());
             actions.extend(RemoveBlock::new(module, &lines, &params).code_actions());
+            actions.extend(RemovePrivateOpaque::new(module, &lines, &params).code_actions());
             GenerateDynamicDecoder::new(module, &lines, &params, &mut actions).code_actions();
             GenerateJsonEncoder::new(
                 module,

compiler-core/src/language_server/tests/action.rs

@@ -131,6 +131,7 @@ const REMOVE_ALL_ECHOS_FROM_THIS_MODULE: &str = "Remove all `echo`s from this mo
 const WRAP_IN_BLOCK: &str = "Wrap in block";
 const GENERATE_VARIANT: &str = "Generate variant";
 const REMOVE_BLOCK: &str = "Remove block";
+const REMOVE_OPAQUE_FROM_PRIVATE_TYPE: &str = "Remove opaque from private type";
 
 macro_rules! assert_code_action {
     ($title:expr, $code:literal, $range:expr $(,)?) => {
@@ -9132,3 +9133,15 @@ fn remove_block_does_not_unwrap_a_block_with_multiple_statements() {
         find_position_of("1").to_selection()
     );
 }
+
+#[test]
+fn remove_opaque_from_private_type() {
+    assert_code_action!(
+        REMOVE_OPAQUE_FROM_PRIVATE_TYPE,
+        "opaque type Wibble {
+  Wobble
+}
+",
+        find_position_of("Wibble").to_selection()
+    );
+}

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__action__remove_opaque_from_private_type.snap

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "opaque type Wibble {\n  Wobble\n}\n"
+---
+----- BEFORE ACTION
+opaque type Wibble {
+            ↑       
+  Wobble
+}
+
+
+----- AFTER ACTION
+type Wibble {
+  Wobble
+}