Wrap file module functions in ErrorInModule.

RELEASES.md

@@ -21,6 +21,7 @@ Breaking changes
 * `EvalAltResult` has a new variant `ErrorInModule` which holds errors when loading an external module.
 * `Module::eval_ast_as_new` now takes an extra boolean parameter, indicating whether to encapsulate the entire module into a separate namespace.
 * Functions in `FileModuleResolver` loaded modules now can cross-call each other, but cannot access the global namespace. For the old behavior, use `MergingFileModuleResolver` instead.
+* New `EvalAltResult::ErrorInModule` variant capturing errors when loading a module from a script file.
 
 New features
 ------------

src/module/mod.rs

@@ -1280,13 +1280,22 @@ impl Module {
                         name,
                         num_args,
                         move |engine: &Engine, _, args: &mut [&mut Dynamic]| {
-                            engine.call_fn_dynamic_raw(
+                            engine
+                                .call_fn_dynamic_raw(
                                     &mut Scope::new(),
                                     &ast_lib,
                                     &fn_name,
                                     &mut None,
                                     args,
                                 )
+                                .map_err(|err| {
+                                    // Wrap the error in a module-error
+                                    Box::new(EvalAltResult::ErrorInModule(
+                                        "".to_string(),
+                                        err,
+                                        Position::none(),
+                                    ))
+                                })
                         },
                     );
                 }

src/result.rs

@@ -184,6 +184,9 @@ impl fmt::Display for EvalAltResult {
             Self::ErrorInFunctionCall(s, err, _) => {
                 write!(f, "Error in call to function '{}': {}", s, err)?
             }
+            Self::ErrorInModule(s, err, _) if s.is_empty() => {
+                write!(f, "Error in module: {}", err)?
+            }
             Self::ErrorInModule(s, err, _) => write!(f, "Error in module '{}': {}", s, err)?,
 
             Self::ErrorFunctionNotFound(s, _)