feat: add empty module validation

Prevent publishing packages with empty modules and emit warnings during compilation when modules contain no public definitions.

Author: vitorsouzaalmeida

compiler-cli/src/publish.rs

@@ -382,6 +382,27 @@ fn do_build_hex_tarball(paths: &ProjectPaths, config: &mut PackageConfig) -> Res
         });
     }
 
+    let mut empty_modules = vec![];
+
+    for module in built.root_package.modules.iter() {
+        let public_definitions = module
+            .ast
+            .definitions
+            .iter()
+            .filter(|def| def.is_public())
+            .count();
+
+        if public_definitions == 0 {
+            empty_modules.push(module.name.clone());
+        }
+    }
+
+    if !empty_modules.is_empty() {
+        return Err(Error::CannotPublishEmptyModules {
+            unfinished: empty_modules,
+        });
+    }
+
     // TODO: If any of the modules in the package contain a leaked internal type then
     // refuse to publish as the package is not yet finished.
     // We need to move aliases in to the type system first.

compiler-core/src/ast.rs

@@ -868,6 +868,16 @@ impl TypedDefinition {
         }
     }
 
+    pub fn is_public(&self) -> bool {
+        match self {
+            Definition::Function(f) => f.publicity.is_public(),
+            Definition::TypeAlias(t) => t.publicity.is_public(),
+            Definition::CustomType(t) => t.publicity.is_public(),
+            Definition::ModuleConstant(c) => c.publicity.is_public(),
+            Definition::Import(_) => false,
+        }
+    }
+
     pub fn find_node(&self, byte_index: u32) -> Option<Located<'_>> {
         match self {
             Definition::Function(function) => {

compiler-core/src/build/package_compiler.rs

@@ -550,6 +550,19 @@ fn analyse(
                 // Register the types from this module so they can be imported into
                 // other modules.
                 let _ = module_types.insert(module.name.clone(), module.ast.type_info.clone());
+                
+                // Check for empty modules and emit warning
+                let public_definitions = module.ast.definitions.iter()
+                    .filter(|def| def.is_public())
+                    .count();
+                
+                if public_definitions == 0 {
+                    warnings.emit(crate::warning::Warning::EmptyModule {
+                        path: module.input_path.clone(),
+                        name: module.name.clone(),
+                    });
+                }
+                
                 // Register the successfully type checked module data so that it can be
                 // used for code generation and in the language server.
                 modules.push(module);

compiler-core/src/error.rs

@@ -298,6 +298,9 @@ file_names.iter().map(|x| x.as_str()).join(", "))]
     )]
     CannotPublishLeakedInternalType { unfinished: Vec<EcoString> },
 
+    #[error("The modules {unfinished:?} are empty and so cannot be published")]
+    CannotPublishEmptyModules { unfinished: Vec<EcoString> },
+
     #[error("Publishing packages to reserve names is not permitted")]
     HexPackageSquatting,
 
@@ -1046,6 +1049,25 @@ Please make sure internal types do not appear in public functions and try again.
                 location: None,
             }],
 
+            Error::CannotPublishEmptyModules { unfinished } => vec![Diagnostic {
+                title: "Cannot publish empty modules".into(),
+                text: format!(
+                    "These modules contain no public definitions and cannot be published:
+
+{}
+
+Please add public functions, types, or constants to these modules, or remove them and try again.
+",
+                    unfinished
+                        .iter()
+                        .map(|name| format!("  - {}", name.as_str()))
+                        .join("\n")
+                ),
+                level: Level::Error,
+                hint: None,
+                location: None,
+            }],
+
             Error::UnableToFindProjectRoot { path } => {
                 let text = wrap_format!(
                     "We were unable to find gleam.toml.

compiler-core/src/warning.rs

@@ -167,6 +167,11 @@ pub enum Warning {
     DeprecatedEnvironmentVariable {
         variable: DeprecatedEnvironmentVariable,
     },
+
+    EmptyModule {
+        path: Utf8PathBuf,
+        name: EcoString,
+    },
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Copy)]
@@ -1371,6 +1376,22 @@ The imported value could not be used in this module anyway."
                     location: None,
                 }
             }
+
+            Warning::EmptyModule { path, name } => Diagnostic {
+                title: "Empty module".into(),
+                text: format!("Module '{}' contains no public definitions.", name),
+                hint: Some("Consider adding public functions, types, or constants, or removing this module.".into()),
+                level: diagnostic::Level::Warning,
+                location: Some(Location {
+                    label: diagnostic::Label {
+                        text: Some("This module is empty".into()),
+                        span: SrcSpan { start: 0, end: 0 },
+                    },
+                    path: path.clone(),
+                    src: EcoString::from(""),
+                    extra_labels: vec![],
+                }),
+            },
         }
     }
 

test-package-compiler/cases/empty_module_publish_validation/gleam.toml

@@ -0,0 +1,7 @@
+name = "empty_module_publish_validation"
+version = "1.0.0"
+description = "Test package with empty modules"
+licences = ["Apache-2.0"]
+
+[dependencies]
+gleam_stdlib = ">= 0.44.0 and < 2.0.0"

test-package-compiler/cases/empty_module_publish_validation/src/empty.gleam

@@ -0,0 +1 @@
+// This is an empty module

test-package-compiler/cases/empty_module_publish_validation/src/main.gleam

@@ -0,0 +1,3 @@
+pub fn main() {
+  "This module has public definitions"
+}

test-package-compiler/src/generated_tests.rs

@@ -0,0 +1,53 @@
+---
+source: test-package-compiler/src/generated_tests.rs
+expression: "./cases/empty_module_publish_validation"
+snapshot_kind: text
+---
+//// /out/lib/the_package/_gleam_artefacts/empty.cache
+<.cache binary>
+
+//// /out/lib/the_package/_gleam_artefacts/empty.cache_meta
+<53 byte binary>
+
+//// /out/lib/the_package/_gleam_artefacts/empty.erl
+-module(empty).
+
+
+//// /out/lib/the_package/_gleam_artefacts/main.cache
+<.cache binary>
+
+//// /out/lib/the_package/_gleam_artefacts/main.cache_meta
+<61 byte binary>
+
+//// /out/lib/the_package/_gleam_artefacts/main.erl
+-module(main).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/main.gleam").
+-export([main/0]).
+
+-file("src/main.gleam", 1).
+-spec main() -> binary().
+main() ->
+    <<"This module has public definitions"/utf8>>.
+
+
+//// /out/lib/the_package/ebin/empty_module_publish_validation.app
+{application, empty_module_publish_validation, [
+    {vsn, "1.0.0"},
+    {applications, [gleam_stdlib]},
+    {description, "Test package with empty modules"},
+    {modules, [empty,
+               main]},
+    {registered, []}
+]}.
+
+
+//// Warning
+warning: Empty module
+  ┌─ src/empty.gleam:1:1
+  │
+1 │ 
+  │ ^ This module is empty
+
+Module 'empty' contains no public definitions.
+Hint: Consider adding public functions, types, or constants, or removing this module.