remove unneeded and buggy UnusedFFIImplementations error

Author: roryc89

src/build/error.rs

@@ -48,12 +48,6 @@ pub enum BuildError {
         path: PathBuf,
         missing: Vec<String>,
     },
-    #[error("The following values in the foreign module for module {module_name} are unused: {}", unused.join(", "))]
-    UnusedFFIImplementations {
-        module_name: String,
-        path: PathBuf,
-        unused: Vec<String>,
-    },
     #[error("CommonJS exports in the ES foreign module for module {module_name} are unsupported: {}", exports.join(", "))]
     UnsupportedFFICommonJSExports {
         module_name: String,
@@ -99,7 +93,6 @@ impl BuildError {
             BuildError::InvalidModuleName { .. } => "SyntaxError".into(),
             BuildError::MissingFFIModule { .. } => "MissingFFIModule".into(),
             BuildError::MissingFFIImplementations { .. } => "MissingFFIImplementations".into(),
-            BuildError::UnusedFFIImplementations { .. } => "UnusedFFIImplementations".into(),
             BuildError::UnsupportedFFICommonJSExports { .. } => "UnsupportedFFICommonJSExports".into(),
             BuildError::UnsupportedFFICommonJSImports { .. } => "UnsupportedFFICommonJSImports".into(),
             BuildError::DeprecatedFFICommonJSModule { .. } => "DeprecatedFFICommonJSModule".into(),

src/build/mod.rs

@@ -748,18 +748,6 @@ fn build_from_sources_impl(
                                             missing,
                                         });
                                     }
-                                    js_ffi::FfiError::UnusedFFIImplementations { unused } => {
-                                        log::debug!(
-                                            "    FFI error in {}: unused implementations: {:?}",
-                                            pm.module_name,
-                                            unused
-                                        );
-                                        build_errors.push(BuildError::UnusedFFIImplementations {
-                                            module_name: pm.module_name.clone(),
-                                            path: pm.path.clone(),
-                                            unused,
-                                        });
-                                    }
                                     js_ffi::FfiError::UnsupportedFFICommonJSExports { exports } => {
                                         build_errors.push(
                                             BuildError::UnsupportedFFICommonJSExports {

src/js_ffi.rs

@@ -31,8 +31,6 @@ pub enum FfiError {
     DeprecatedFFICommonJSModule,
     /// Declared `foreign import` but not exported in FFI
     MissingFFIImplementations { missing: Vec<String> },
-    /// Exported in FFI but no corresponding `foreign import`
-    UnusedFFIImplementations { unused: Vec<String> },
     /// CommonJS exports mixed with ES module syntax
     UnsupportedFFICommonJSExports { exports: Vec<String> },
     /// CommonJS imports (require) mixed with ES module syntax
@@ -339,9 +337,5 @@ pub fn validate_foreign_module(
         errors.push(FfiError::MissingFFIImplementations { missing });
     }
 
-    if !unused.is_empty() {
-        errors.push(FfiError::UnusedFFIImplementations { unused });
-    }
-
     errors
 }

src/main.rs

@@ -74,29 +74,32 @@ fn main() {
                 log::debug!("Failed to save build cache: {e}");
             }
 
-            let mut error_count = 0;
+            let mut error_messages: Vec<String> = Vec::new();
 
             for err in &result.build_errors {
-                eprintln!("[error] {err}");
-                error_count += 1;
+                error_messages.push(format!("{err}"));
             }
 
-            for module in &result.modules {
+            let total = result.modules.len();
+            for (i, module) in result.modules.iter().enumerate() {
                 if module.type_errors.is_empty() {
-                    println!("[ok] {}", module.module_name);
+                    println!("[{}/{}] {}", i + 1, total, module.module_name);
                 } else {
                     for err in &module.type_errors {
-                        eprintln!("[error] {}: {err}", module.module_name);
-                        error_count += 1;
+                        error_messages.push(format!("{}: {err}", module.module_name));
                     }
                 }
             }
 
-            if error_count > 0 {
+            if !error_messages.is_empty() {
+                let error_count = error_messages.len();
                 eprintln!(
-                    "\nCompilation failed with {error_count} error{}.",
+                    "\nCompilation failed with {error_count} error{}:\n",
                     if error_count == 1 { "" } else { "s" }
                 );
+                for msg in &error_messages {
+                    eprintln!("  {msg}");
+                }
                 std::process::exit(1);
             } else {
                 println!(

tests/build.rs

@@ -535,7 +535,6 @@ fn matches_expected_error(
         "UnsupportedTypeInKind" => has("UnsupportedTypeInKind"),
         "CannotDeriveInvalidConstructorArg" => has("CannotDeriveInvalidConstructorArg"),
         "MissingFFIImplementations" => has("MissingFFIImplementations"),
-        "UnusedFFIImplementations" => has("UnusedFFIImplementations"),
         "UnsupportedFFICommonJSExports" => has("UnsupportedFFICommonJSExports"),
         "UnsupportedFFICommonJSImports" => has("UnsupportedFFICommonJSImports"),
         "DeprecatedFFICommonJSModule" => has("DeprecatedFFICommonJSModule"),