Add create unknown module code action

Author: tarkah

CHANGELOG.md

@@ -295,6 +295,15 @@
 
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- The language server now offers a code action to create unknown modules
+  when an import is added for a module that doesn't exist.
+
+  For example, if `import wobble/woo` is added to `src/wiggle.gleam`,
+  then a code action to create `src/wobble/woo.gleam` will be presented
+  when triggered over `import wobble/woo`.
+
+  ([Cory Forsstrom](https://github.com/tarkah))
+
 ### Formatter
 
 - The formatter now removes needless multiple negations that are safe to remove.

compiler-core/src/language_server/code_action.rs

@@ -10,24 +10,29 @@ use crate::{
         TypedPattern, TypedPipelineAssignment, TypedRecordConstructor, TypedStatement, TypedUse,
         visit::Visit as _,
     },
-    build::{Located, Module},
+    build::{Located, Module, Origin},
     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},
+    paths::ProjectPaths,
     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 +51,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 +81,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 +7909,106 @@ fn single_expression(expression: &TypedExpr) -> Option<&TypedExpr> {
         expression => Some(expression),
     }
 }
+
+/// Code action to create unknown modules when an import is added for a
+/// module that doesn't exist.
+///
+/// For example, if `import wobble/woo` is added to `src/wiggle.gleam`,
+/// then a code action to create `src/wobble/woo.gleam` will be presented
+/// when triggered over `import wobble/woo`.
+pub struct CreateUnknownModule<'a> {
+    module: &'a Module,
+    lines: &'a LineNumbers,
+    params: &'a CodeActionParams,
+    paths: &'a ProjectPaths,
+    error: &'a Option<Error>,
+}
+
+impl<'a> CreateUnknownModule<'a> {
+    pub fn new(
+        module: &'a Module,
+        lines: &'a LineNumbers,
+        params: &'a CodeActionParams,
+        paths: &'a ProjectPaths,
+        error: &'a Option<Error>,
+    ) -> Self {
+        Self {
+            module,
+            lines,
+            params,
+            paths,
+            error,
+        }
+    }
+
+    pub fn code_actions(self) -> Vec<CodeAction> {
+        struct UnknownModule<'a> {
+            name: &'a EcoString,
+            location: &'a SrcSpan,
+        }
+
+        let mut actions = vec![];
+
+        // This code action can be derived from UnknownModule type errors. If those
+        // errors don't exist, there are no actions to add.
+        let Some(Error::Type { errors, .. }) = self.error else {
+            return actions;
+        };
+
+        // Span of the code action so we can check if it exists within the span of
+        // the UnkownModule type error
+        let code_action_span = lsp_range_to_src_span(self.params.range, self.lines);
+
+        // Origin directory we can build the new module path from
+        let origin_directory = match self.module.origin {
+            Origin::Src => self.paths.src_directory(),
+            Origin::Test => self.paths.test_directory(),
+            Origin::Dev => self.paths.dev_directory(),
+        };
+
+        // Filter for any UnknownModule type errors
+        let unknown_modules = errors.iter().filter_map(|error| {
+            if let TypeError::UnknownModule { name, location, .. } = error {
+                return Some(UnknownModule { name, location });
+            }
+
+            None
+        });
+
+        // For each UnknownModule type error, check to see if it contains the
+        // incoming code action & if so, add a document change to create the module
+        for unknown_module in unknown_modules {
+            // Was this code action triggered within the UnknownModule error?
+            let error_contains_action = unknown_module.location.contains(code_action_span.start)
+                && unknown_module.location.contains(code_action_span.end);
+
+            if !error_contains_action {
+                continue;
+            }
+
+            let uri =
+                Url::from_file_path(format!("{origin_directory}/{}.gleam", unknown_module.name))
+                    .expect("origin directory is absolute");
+
+            CodeActionBuilder::new(format!(
+                "Create module {}/{}.gleam",
+                self.module.origin.folder_name(),
+                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,10 @@ where
             )
             .code_actions();
             AddAnnotations::new(module, &lines, &params).code_action(&mut actions);
+            actions.extend(
+                CreateUnknownModule::new(module, &lines, &params, &this.paths, &this.error)
+                    .code_actions(),
+            );
             Ok(if actions.is_empty() {
                 None
             } else {