Add create unknown module code action

Author: tarkah

compiler-core/src/ast.rs

@@ -2265,6 +2265,10 @@ impl SrcSpan {
         byte_index >= self.start && byte_index <= self.end
     }
 
+    pub fn intersects(&self, other: Self) -> bool {
+        self.start < other.end && self.end > other.start
+    }
+
     /// Merges two spans into a new one that starts at the start of the smaller
     /// one and ends at the end of the bigger one. For example:
     ///

compiler-core/src/language_server/code_action.rs

@@ -14,20 +14,24 @@ use crate::{
     config::PackageConfig,
     exhaustiveness::CompiledCase,
     io::{BeamCompiler, CommandExecutor, FileSystemReader, FileSystemWriter},
-    language_server::{edits, reference::FindVariableReferences},
+    language_server::{edits, lsp_range_to_src_span, reference::FindVariableReferences},
     line_numbers::LineNumbers,
     parse::{extra::ModuleExtra, lexer::str_to_keyword},
     strings::to_snake_case,
     type_::{
-        self, FieldMap, ModuleValueConstructor, Type, TypeVar, TypedCallArg, ValueConstructor,
+        self, Error as TypeError, FieldMap, ModuleValueConstructor, Type, TypeVar, TypedCallArg,
+        ValueConstructor,
         error::{ModuleSuggestion, VariableDeclaration, VariableOrigin},
         printer::Printer,
     },
 };
 use ecow::{EcoString, eco_format};
 use im::HashMap;
 use itertools::Itertools;
-use lsp_types::{CodeAction, CodeActionKind, CodeActionParams, Position, Range, TextEdit, Url};
+use lsp_types::{
+    CodeAction, CodeActionKind, CodeActionParams, CreateFile, CreateFileOptions,
+    DocumentChangeOperation, DocumentChanges, Position, Range, ResourceOp, TextEdit, Url,
+};
 use vec1::{Vec1, vec1};
 
 use super::{
@@ -46,7 +50,7 @@ pub struct CodeActionBuilder {
 }
 
 impl CodeActionBuilder {
-    pub fn new(title: &str) -> Self {
+    pub fn new(title: impl ToString) -> Self {
         Self {
             action: CodeAction {
                 title: title.to_string(),
@@ -76,6 +80,15 @@ impl CodeActionBuilder {
         self
     }
 
+    pub fn document_changes(mut self, changes: DocumentChanges) -> Self {
+        let mut edit = self.action.edit.take().unwrap_or_default();
+
+        edit.document_changes = Some(changes);
+
+        self.action.edit = Some(edit);
+        self
+    }
+
     pub fn preferred(mut self, is_preferred: bool) -> Self {
         self.action.is_preferred = Some(is_preferred);
         self
@@ -7895,3 +7908,91 @@ fn single_expression(expression: &TypedExpr) -> Option<&TypedExpr> {
         expression => Some(expression),
     }
 }
+
+/// Code action to create an unknown module
+///
+/// ```gleam
+/// // foo.gleam
+/// // Diagnostic: Unknown module
+/// import foo/bar/baz
+/// ```
+///
+/// Would create:
+///
+/// ```gleam
+/// // foo/bar/baz.gleam
+/// ```
+///
+pub struct CreateUnknownModule<'a> {
+    module: &'a Module,
+    error: &'a Option<Error>,
+    code_action_span: SrcSpan,
+}
+
+impl<'a> CreateUnknownModule<'a> {
+    pub fn new(
+        module: &'a Module,
+        lines: &'a LineNumbers,
+        params: &'a CodeActionParams,
+        error: &'a Option<Error>,
+    ) -> Self {
+        Self {
+            module,
+            error,
+            code_action_span: lsp_range_to_src_span(params.range, lines),
+        }
+    }
+
+    pub fn code_actions(self) -> Vec<CodeAction> {
+        struct UnknownModule<'a> {
+            name: &'a EcoString,
+            location: &'a SrcSpan,
+        }
+
+        let mut actions = vec![];
+
+        let Some(Error::Type { errors, .. }) = self.error else {
+            return actions;
+        };
+
+        let origin_path = self
+            .module
+            .input_path
+            .as_str()
+            .strip_suffix(&format!("{}.gleam", self.module.name))
+            .expect("origin is ancestor of module path");
+
+        let unknown_modules = errors.iter().filter_map(|error| {
+            if let TypeError::UnknownModule { name, location, .. } = error {
+                return Some(UnknownModule { name, location });
+            }
+
+            None
+        });
+
+        for unknown_module in unknown_modules {
+            if !self.code_action_span.intersects(*unknown_module.location) {
+                continue;
+            }
+
+            let uri = Url::from_file_path(format!("{origin_path}/{}.gleam", unknown_module.name))
+                .expect("origin path is absolute");
+
+            CodeActionBuilder::new(format!("Create module {}.gleam", unknown_module.name))
+                .kind(CodeActionKind::QUICKFIX)
+                .document_changes(DocumentChanges::Operations(vec![
+                    DocumentChangeOperation::Op(ResourceOp::Create(CreateFile {
+                        uri,
+                        options: Some(CreateFileOptions {
+                            overwrite: Some(false),
+                            ignore_if_exists: Some(true),
+                        }),
+                        annotation_id: None,
+                    })),
+                ]))
+                .push_to(&mut actions);
+        }
+
+        actions
+    }
+}

compiler-core/src/language_server/engine.rs

@@ -42,7 +42,7 @@ use super::{
     DownloadDependencies, MakeLocker,
     code_action::{
         AddAnnotations, CodeActionBuilder, ConvertFromUse, ConvertToFunctionCall, ConvertToPipe,
-        ConvertToUse, ExpandFunctionCapture, ExtractConstant, ExtractVariable,
+        ConvertToUse, CreateUnknownModule, ExpandFunctionCapture, ExtractConstant, ExtractVariable,
         FillInMissingLabelledArgs, FillUnusedFields, FixBinaryOperation,
         FixTruncatedBitArraySegment, GenerateDynamicDecoder, GenerateFunction, GenerateJsonEncoder,
         GenerateVariant, InlineVariable, InterpolateString, LetAssertToCase, PatternMatchOnValue,
@@ -451,6 +451,9 @@ where
             )
             .code_actions();
             AddAnnotations::new(module, &lines, &params).code_action(&mut actions);
+            actions.extend(
+                CreateUnknownModule::new(module, &lines, &params, &this.error).code_actions(),
+            );
             Ok(if actions.is_empty() {
                 None
             } else {