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,104 @@ fn single_expression(expression: &TypedExpr) -> Option<&TypedExpr> {
         expression => Some(expression),
     }
 }
+
+/// Code action to create an unknown child module
+///
+/// ```gleam
+/// // foo.gleam
+/// // Diagnostic: Unknown module
+/// import foo/bar
+/// ```
+///
+/// Would create:
+///
+/// ```gleam
+/// // foo/bar.gleam
+/// ```
+///
+pub struct CreateUnknownChildModule<'a> {
+    module: &'a Module,
+    params: &'a CodeActionParams,
+    error: &'a Option<Error>,
+    code_action_span: SrcSpan,
+}
+
+impl<'a> CreateUnknownChildModule<'a> {
+    pub fn new(
+        module: &'a Module,
+        lines: &'a LineNumbers,
+        params: &'a CodeActionParams,
+        error: &'a Option<Error>,
+    ) -> Self {
+        Self {
+            module,
+            params,
+            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 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 Some(relative_name) = unknown_module
+                .name
+                .strip_prefix(self.module.name.as_str())
+                .map(|s| s.trim_start_matches('/'))
+            else {
+                continue;
+            };
+
+            // Must be a direct child of the current module (doesn't contain / separator)
+            if relative_name.contains('/') {
+                continue;
+            }
+
+            let mut uri = self.params.text_document.uri.clone();
+
+            uri.set_path(&format!(
+                "{}/{}.gleam",
+                uri.path().trim_end_matches(".gleam"),
+                relative_name
+            ));
+
+            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,8 +42,8 @@ use super::{
     DownloadDependencies, MakeLocker,
     code_action::{
         AddAnnotations, CodeActionBuilder, ConvertFromUse, ConvertToFunctionCall, ConvertToPipe,
-        ConvertToUse, ExpandFunctionCapture, ExtractConstant, ExtractVariable,
-        FillInMissingLabelledArgs, FillUnusedFields, FixBinaryOperation,
+        ConvertToUse, CreateUnknownChildModule, ExpandFunctionCapture, ExtractConstant,
+        ExtractVariable, FillInMissingLabelledArgs, FillUnusedFields, FixBinaryOperation,
         FixTruncatedBitArraySegment, GenerateDynamicDecoder, GenerateFunction, GenerateJsonEncoder,
         GenerateVariant, InlineVariable, InterpolateString, LetAssertToCase, PatternMatchOnValue,
         RedundantTupleInCaseSubject, RemoveEchos, RemoveUnusedImports, UseLabelShorthandSyntax,
@@ -451,6 +451,9 @@ where
             )
             .code_actions();
             AddAnnotations::new(module, &lines, &params).code_action(&mut actions);
+            actions.extend(
+                CreateUnknownChildModule::new(module, &lines, &params, &this.error).code_actions(),
+            );
             Ok(if actions.is_empty() {
                 None
             } else {