Add create unknown module code action

Author: tarkah

CHANGELOG.md

@@ -324,6 +324,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::{
         TypedExpr, TypedModuleConstant, 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
@@ -1571,7 +1585,7 @@ impl<'a> QualifiedToUnqualifiedImportSecondPass<'a> {
         }
         self.edit_import();
         let mut action = Vec::with_capacity(1);
-        CodeActionBuilder::new(&format!(
+        CodeActionBuilder::new(format!(
             "Unqualify {}.{}",
             self.qualified_constructor.used_name, self.qualified_constructor.constructor
         ))
@@ -1959,7 +1973,7 @@ impl<'a> UnqualifiedToQualifiedImportSecondPass<'a> {
             constructor,
             ..
         } = self.unqualified_constructor;
-        CodeActionBuilder::new(&format!(
+        CodeActionBuilder::new(format!(
             "Qualify {} as {}.{}",
             constructor.used_name(),
             module_name,
@@ -7081,7 +7095,7 @@ impl<'a> FixBinaryOperation<'a> {
         self.edits.replace(location, replacement.name().into());
 
         let mut action = Vec::with_capacity(1);
-        CodeActionBuilder::new(&format!("Use `{}`", replacement.name()))
+        CodeActionBuilder::new(format!("Use `{}`", replacement.name()))
             .kind(CodeActionKind::REFACTOR_REWRITE)
             .changes(self.params.text_document.uri.clone(), self.edits.edits)
             .preferred(true)
@@ -7164,7 +7178,7 @@ impl<'a> FixTruncatedBitArraySegment<'a> {
             .replace(truncation.value_location, replacement.clone());
 
         let mut action = Vec::with_capacity(1);
-        CodeActionBuilder::new(&format!("Replace with `{replacement}`"))
+        CodeActionBuilder::new(format!("Replace with `{replacement}`"))
             .kind(CodeActionKind::REFACTOR_REWRITE)
             .changes(self.params.text_document.uri.clone(), self.edits.edits)
             .preferred(true)
@@ -8006,3 +8020,105 @@ 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_path(&format!("{origin_directory}/{}.gleam", unknown_module.name))
+                .expect("origin directory is absolute");
+
+            CodeActionBuilder::new(format!(
+                "Create {}/{}.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,
@@ -454,6 +454,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 {
@@ -1540,7 +1544,7 @@ fn code_action_fix_names(
                 new_text: correction.to_string(),
             };
 
-            CodeActionBuilder::new(&format!("Rename to {correction}"))
+            CodeActionBuilder::new(format!("Rename to {correction}"))
                 .kind(lsp_types::CodeActionKind::QUICKFIX)
                 .changes(uri.clone(), vec![edit])
                 .preferred(true)

compiler-core/src/language_server/tests.rs

@@ -24,6 +24,7 @@ use lsp_types::{Position, TextDocumentIdentifier, TextDocumentPositionParams, Ur
 
 use crate::{
     Result,
+    build::Origin,
     config::PackageConfig,
     io::{
         BeamCompiler, Command, CommandExecutor, FileSystemReader, FileSystemWriter, ReadDir,
@@ -597,6 +598,18 @@ impl<'a> TestProject<'a> {
         TextDocumentPositionParams::new(TextDocumentIdentifier::new(url), position)
     }
 
+    pub fn build_src_path(&self, position: Position, module: &str) -> TextDocumentPositionParams {
+        let path = Utf8PathBuf::from(if cfg!(target_family = "windows") {
+            format!(r"\\?\C:\src\{module}.gleam")
+        } else {
+            format!("/src/{module}.gleam")
+        });
+
+        let url = Url::from_file_path(path).unwrap();
+
+        TextDocumentPositionParams::new(TextDocumentIdentifier::new(url), position)
+    }
+
     pub fn build_test_path(
         &self,
         position: Position,
@@ -649,6 +662,27 @@ impl<'a> TestProject<'a> {
         (engine, param)
     }
 
+    pub fn positioned_with_io_in_src(
+        &self,
+        position: Position,
+        module: &str,
+    ) -> (
+        LanguageServerEngine<LanguageServerTestIO, LanguageServerTestIO>,
+        TextDocumentPositionParams,
+    ) {
+        let mut io = LanguageServerTestIO::new();
+        let mut engine = self.build_engine(&mut io);
+
+        // Add the final module we're going to be positioning the cursor in.
+        _ = io.src_module("app", self.src);
+
+        let _response = engine.compile_please();
+
+        let param = self.build_src_path(position, module);
+
+        (engine, param)
+    }
+
     pub fn positioned_with_io_in_test(
         &self,
         position: Position,
@@ -663,8 +697,7 @@ impl<'a> TestProject<'a> {
         // Add the final module we're going to be positioning the cursor in.
         _ = io.src_module("app", self.src);
 
-        let response = engine.compile_please();
-        assert!(response.result.is_ok());
+        let _response = engine.compile_please();
 
         let param = self.build_test_path(position, test_name);
 
@@ -685,8 +718,7 @@ impl<'a> TestProject<'a> {
         // Add the final module we're going to be positioning the cursor in.
         _ = io.src_module("app", self.src);
 
-        let response = engine.compile_please();
-        assert!(response.result.is_ok());
+        let _response = engine.compile_please();
 
         let param = self.build_dev_path(position, test_name);
 
@@ -695,16 +727,41 @@ impl<'a> TestProject<'a> {
 
     pub fn at<T>(
         &self,
-        position: Position,
+        cursor: impl Into<Cursor<'a>>,
         executor: impl FnOnce(
             &mut LanguageServerEngine<LanguageServerTestIO, LanguageServerTestIO>,
             TextDocumentPositionParams,
             EcoString,
         ) -> T,
     ) -> T {
-        let (mut engine, params) = self.positioned_with_io(position);
+        let at = cursor.into();
 
-        executor(&mut engine, params, self.src.into())
+        let find_module = |modules: &[(&'a str, &'a str)], module: &'a str| {
+            modules
+                .iter()
+                .find_map(|(name, code)| (*name == module).then_some(*code))
+                .expect("Module doesn't exist")
+        };
+
+        let ((mut engine, params), code) = match at {
+            Cursor::Root(position) => (self.positioned_with_io(position), self.src),
+            Cursor::Module(origin, module, position) => match origin {
+                Origin::Src => (
+                    self.positioned_with_io_in_src(position, module),
+                    find_module(&self.root_package_modules, module),
+                ),
+                Origin::Test => (
+                    self.positioned_with_io_in_test(position, module),
+                    find_module(&self.test_modules, module),
+                ),
+                Origin::Dev => (
+                    self.positioned_with_io_in_dev(position, module),
+                    find_module(&self.dev_modules, module),
+                ),
+            },
+        };
+
+        executor(&mut engine, params, code.into())
     }
 }
 
@@ -841,3 +898,14 @@ pub fn apply_code_edit(src: &str, mut change: Vec<lsp_types::TextEdit>) -> Strin
 
     result
 }
+
+pub enum Cursor<'a> {
+    Root(Position),
+    Module(Origin, &'a str, Position),
+}
+
+impl From<Position> for Cursor<'_> {
+    fn from(value: Position) -> Self {
+        Self::Root(value)
+    }
+}