throw an error instead of allowing builtin modules to be overwritten (#2042)

src/machine/loader.rs

@@ -265,6 +265,10 @@ pub trait LoadState<'a>: Sized {
         loader: &Loader<'a, Self>,
         key: PredicateKey,
     ) -> Result<(), SessionError>;
+
+    fn err_on_builtin_module_overwrite(_module_name: Atom) -> Result<(), SessionError> {
+        Ok(())
+    }
 }
 
 pub struct LiveLoadAndMachineState<'a> {
@@ -353,6 +357,15 @@ impl<'a> LoadState<'a> for LiveLoadAndMachineState<'a> {
 
         Ok(())
     }
+
+    #[inline]
+    fn err_on_builtin_module_overwrite(module_name: Atom) -> Result<(), SessionError> {
+        if LIBRARIES.borrow().contains_key(&*module_name.as_str()) {
+            Err(SessionError::CannotOverwriteBuiltInModule(module_name))
+        } else {
+            Ok(())
+        }
+    }
 }
 
 impl<'a> LoadState<'a> for BootstrappingLoadState<'a> {
@@ -533,11 +546,13 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
                 self.add_meta_predicate_record(module_name, name, meta_specs);
             }
             Declaration::Module(module_decl) => {
-                self.payload.compilation_target = CompilationTarget::Module(module_decl.name);
+                let module_name = module_decl.name;
+
+                self.payload.compilation_target = CompilationTarget::Module(module_name);
                 self.payload.predicates.compilation_target = self.payload.compilation_target;
 
                 let listing_src = self.payload.term_stream.listing_src().clone();
-                self.add_module(module_decl, listing_src);
+                self.add_module(module_decl, listing_src)?;
             }
             Declaration::NonCountedBacktracking(name, arity) => {
                 self.payload.non_counted_bt_preds.insert((name, arity));
@@ -1849,9 +1864,7 @@ impl Machine {
             2,
         )?;
 
-        let path = cell_as_atom!(self
-            .machine_st
-            .store(self.machine_st.deref(self.machine_st.registers[2])));
+        let path = cell_as_atom!(self.deref_register(2));
 
         self.load_contexts
             .push(LoadContext::new(&*path.as_str(), stream));