refactor remove unused imports into its own code action builder

compiler-core/src/language_server/code_action.rs

···
     Error, STDLIB_PACKAGE_NAME, analyse,
     ast::{
         self, AssignName, AssignmentKind, BitArraySegmentTruncation, CallArg, CustomType,
-        FunctionLiteralKind, ImplicitCallArgOrigin, PIPE_PRECEDENCE, Pattern,
+        FunctionLiteralKind, ImplicitCallArgOrigin, Import, PIPE_PRECEDENCE, Pattern,
         PatternUnusedArguments, PipelineAssignmentKind, RecordConstructor, SrcSpan, TodoKind,
         TypedArg, TypedAssignment, TypedExpr, TypedModuleConstant, TypedPattern,
         TypedPipelineAssignment, TypedRecordConstructor, TypedStatement, TypedUse,
···
 }
 
 pub struct QualifiedConstructor<'a> {
-    import: &'a ast::Import<EcoString>,
+    import: &'a Import<EcoString>,
     module_aliased: bool,
     used_name: EcoString,
     constructor: EcoString,
···
         module_name: &EcoString,
         constructor: &EcoString,
         layer: ast::Layer,
-    ) -> Option<&'a ast::Import<EcoString>> {
+    ) -> Option<&'a Import<EcoString>> {
         let mut matching_import = None;
 
         for def in &self.module.ast.definitions {
···
 
     fn find_last_char_before_closing_brace(&self) -> Option<(usize, char)> {
         let QualifiedConstructor {
-            import: ast::Import { location, .. },
+            import: Import { location, .. },
             ..
         } = self.qualified_constructor;
         let import_code = self.get_import_code();
···
 
     fn get_import_code(&self) -> &str {
         let QualifiedConstructor {
-            import: ast::Import { location, .. },
+            import: Import { location, .. },
             ..
         } = self.qualified_constructor;
         self.module
···
     // Handle inserting into an unbraced import
     fn insert_into_unbraced_import(&self, name: String, module_aliased: bool) -> (u32, String) {
         let QualifiedConstructor {
-            import: ast::Import { location, .. },
+            import: Import { location, .. },
             ..
         } = self.qualified_constructor;
         if !module_aliased {
···
     // Handle inserting into a braced import
     fn insert_into_braced_import(&self, name: String) -> (u32, String) {
         let QualifiedConstructor {
-            import: ast::Import { location, .. },
+            import: Import { location, .. },
             ..
         } = self.qualified_constructor;
         if let Some((pos, c)) = self.find_last_char_before_closing_brace() {
···
         ast::visit::visit_typed_expr_bit_array_segment(self, segment);
     }
 }
+
+/// Code action builder to remove unused imports and values.
+///
+pub struct RemoveUnusedImports<'a> {
+    module: &'a Module,
+    params: &'a CodeActionParams,
+    imports: Vec<&'a Import<EcoString>>,
+    edits: TextEdits<'a>,
+}
+
+#[derive(Debug)]
+enum UnusedImport {
+    Value(SrcSpan),
+    Module(SrcSpan),
+    ModuleAlias(SrcSpan),
+}
+
+impl UnusedImport {
+    fn location(&self) -> SrcSpan {
+        match self {
+            UnusedImport::Value(location)
+            | UnusedImport::Module(location)
+            | UnusedImport::ModuleAlias(location) => *location,
+        }
+    }
+}
+
+impl<'a> RemoveUnusedImports<'a> {
+    pub fn new(
+        module: &'a Module,
+        line_numbers: &'a LineNumbers,
+        params: &'a CodeActionParams,
+    ) -> Self {
+        Self {
+            module,
+            params,
+            edits: TextEdits::new(line_numbers),
+            imports: vec![],
+        }
+    }
+
+    pub fn code_actions(mut self) -> Vec<CodeAction> {
+        // If there's no import in the module then there can't be any unused
+        // import to remove.
+        self.visit_typed_module(&self.module.ast);
+        if self.imports.is_empty() {
+            return vec![];
+        }
+
+        let unused_imports = (self.module.ast.type_info.warnings.iter())
+            .filter_map(|warning| match warning {
+                type_::Warning::UnusedImportedValue { location, .. } => {
+                    Some(UnusedImport::Value(*location))
+                }
+                type_::Warning::UnusedImportedModule { location, .. } => {
+                    Some(UnusedImport::Module(*location))
+                }
+                type_::Warning::UnusedImportedModuleAlias { location, .. } => {
+                    Some(UnusedImport::ModuleAlias(*location))
+                }
+                _ => None,
+            })
+            .collect_vec();
+
+        println!("{:#?}", unused_imports);
+        println!("{:#?}", self.params.range);
+
+        // If the cursor is not over any of the unused imports then we don't offer
+        // the code action.
+        let hovering_unused_import = unused_imports.iter().any(|import| {
+            let unused_range = self.edits.src_span_to_lsp_range(import.location());
+            overlaps(self.params.range, unused_range)
+        });
+        if !hovering_unused_import {
+            return vec![];
+        }
+
+        // Otherwise we start removing all unused imports:
+        for import in unused_imports {
+            match import {
+                // When an entire module is unused we can delete its entire location
+                // in the source code.
+                UnusedImport::Module(location) | UnusedImport::ModuleAlias(location) => {
+                    if self.edits.line_numbers.spans_entire_line(&location) {
+                        // If the unused module spans over the entire line then
+                        // we also take care of removing the following newline
+                        // characther!
+                        self.edits.delete(SrcSpan {
+                            start: location.start,
+                            end: location.end + 1,
+                        })
+                    } else {
+                        self.edits.delete(location)
+                    }
+                }
+
+                // When removing unused imported values we have to be a bit more
+                // careful: an unused value might be followed by a comma that we
+                // also need to remove! So we have to look for this imported
+                // value and also delete all characters between it and the
+                // following imported value. For example:
+                //
+                // ```gleam
+                // import wibble.{wobble,    woo}
+                // //             ^^^^^^^^^^^ If wobble is unused we must remove
+                // //                         all of this!
+                // ```
+                //
+                UnusedImport::Value(_) => continue,
+            }
+        }
+
+        let mut action = Vec::with_capacity(1);
+        CodeActionBuilder::new("Remove unused imports")
+            .kind(CodeActionKind::REFACTOR_REWRITE)
+            .changes(self.params.text_document.uri.clone(), self.edits.edits)
+            .preferred(true)
+            .push_to(&mut action);
+        action
+    }
+}
+
+impl<'ast> ast::visit::Visit<'ast> for RemoveUnusedImports<'ast> {
+    fn visit_typed_module(&mut self, module: &'ast ast::TypedModule) {
+        self.imports = module
+            .definitions
+            .iter()
+            .filter_map(|definition| match definition {
+                ast::Definition::Import(import) => Some(import),
+                _ => None,
+            })
+            .collect_vec();
+    }
+}

compiler-core/src/language_server/engine.rs

···
         FillInMissingLabelledArgs, FillUnusedFields, FixBinaryOperation,
         FixTruncatedBitArraySegment, GenerateDynamicDecoder, GenerateFunction, GenerateJsonEncoder,
         GenerateVariant, InlineVariable, InterpolateString, LetAssertToCase, PatternMatchOnValue,
-        RedundantTupleInCaseSubject, RemoveEchos, UseLabelShorthandSyntax, WrapInBlock,
-        code_action_add_missing_patterns, code_action_convert_qualified_constructor_to_unqualified,
+        RedundantTupleInCaseSubject, RemoveEchos, RemoveUnusedImports, UseLabelShorthandSyntax,
+        WrapInBlock, code_action_add_missing_patterns,
+        code_action_convert_qualified_constructor_to_unqualified,
         code_action_convert_unqualified_constructor_to_qualified, code_action_import_module,
         code_action_inexhaustive_let_to_case,
     },
···
             let lines = LineNumbers::new(&module.code);
 
             code_action_unused_values(module, &lines, &params, &mut actions);
-            code_action_unused_imports(module, &lines, &params, &mut actions);
+            actions.extend(RemoveUnusedImports::new(module, &lines, &params).code_actions());
             code_action_convert_qualified_constructor_to_unqualified(
                 module,
                 &lines,
···
     }
 }
 
-/// Code action to remove unused imports.
-///
-fn code_action_unused_imports(
-    module: &Module,
-    line_numbers: &LineNumbers,
-    params: &lsp::CodeActionParams,
-    actions: &mut Vec<CodeAction>,
-) {
-    let uri = &params.text_document.uri;
-    let unused: Vec<&SrcSpan> = module
-        .ast
-        .type_info
-        .warnings
-        .iter()
-        .filter_map(|warning| match warning {
-            type_::Warning::UnusedImportedModuleAlias { location, .. }
-            | type_::Warning::UnusedImportedModule { location, .. } => Some(location),
-            _ => None,
-        })
-        .collect();
-
-    if unused.is_empty() {
-        return;
-    }
-
-    let mut hovered = false;
-    let mut edits = Vec::with_capacity(unused.len());
-
-    for unused in unused {
-        let SrcSpan { start, end } = *unused;
-
-        // If removing an unused alias or at the beginning of the file, don't backspace
-        // Otherwise, adjust the end position by 1 to ensure the entire line is deleted with the import.
-        let adjusted_end = if delete_line(unused, line_numbers) {
-            end + 1
-        } else {
-            end
-        };
-
-        let range = src_span_to_lsp_range(SrcSpan::new(start, adjusted_end), line_numbers);
-        // Keep track of whether any unused import has is where the cursor is
-        hovered = hovered || overlaps(params.range, range);
-
-        edits.push(TextEdit {
-            range,
-            new_text: "".into(),
-        });
-    }
-
-    // If none of the imports are where the cursor is we do nothing
-    if !hovered {
-        return;
-    }
-    edits.sort_by_key(|edit| edit.range.start);
-
-    CodeActionBuilder::new("Remove unused imports")
-        .kind(lsp_types::CodeActionKind::QUICKFIX)
-        .changes(uri.clone(), edits)
-        .preferred(true)
-        .push_to(actions);
-}
-
 struct NameCorrection {
     pub location: SrcSpan,
     pub correction: EcoString,
···
                 .push_to(actions);
         }
     }
-}
-
-// Check if the edit empties a whole line; if so, delete the line.
-fn delete_line(span: &SrcSpan, line_numbers: &LineNumbers) -> bool {
-    line_numbers.line_starts.iter().any(|&line_start| {
-        line_start == span.start && line_numbers.line_starts.contains(&(span.end + 1))
-    })
 }
 
 fn get_expr_qualified_name(expression: &TypedExpr) -> Option<(&EcoString, &EcoString)> {

compiler-core/src/line_numbers.rs

···
-use std::collections::HashMap;
-
+use crate::ast::SrcSpan;
 use lsp_types::Position;
+use std::collections::HashMap;
 
 /// A struct which contains information about line numbers of a source file,
 /// and can convert between byte offsets that are used in the compiler and
···
         }
 
         u8_offset
+    }
+
+    /// Checks if the given span spans an entire line (excluding the newline
+    /// character itself).
+    pub fn spans_entire_line(&self, span: &SrcSpan) -> bool {
+        self.line_starts.iter().any(|&line_start| {
+            line_start == span.start && self.line_starts.contains(&(span.end + 1))
+        })
     }
 }