give dynamic predicates a better respect for module bounds

src/prolog/machine/compile.rs

@@ -176,15 +176,15 @@ fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName) ->
 
     match wam.indices.modules.get_mut(&name.owning_module()) {
         Some(module) => {
-            let code_dir = mem::replace(&mut indices.code_dir, CodeDir::new());            
-            module.code_dir.extend(as_module_code_dir(code_dir));                        
+            let code_dir = mem::replace(&mut indices.code_dir, CodeDir::new());
+            module.code_dir.extend(as_module_code_dir(code_dir));
         },
         _ => unreachable!()
     };
-    
+
     wam.code_repo.code.extend(module_code.into_iter());
     clause_code_generator.add_clause_code(wam);
-    
+
     EvalSession::EntrySuccess
 }
 
@@ -216,8 +216,8 @@ impl ClauseCodeGenerator {
                 continue;
             }
 
-            if let Some(idx) = wam.indices.code_dir.get(&(name.clone(), arity)) {
-                if !idx.is_undefined() && name.owning_module() != idx.module_name() {
+            if let Some(info) = wam.indices.dynamic_code_dir.get(&(name.clone(), arity)) {
+                if info.module_src != name.owning_module() {
                     let err_str = format!("{}/{}", name.as_str(), arity);
                     let err_str = clause_name!(err_str, wam.indices.atom_tbl());
 
@@ -249,9 +249,11 @@ impl ClauseCodeGenerator {
         wam.code_repo.code.extend(self.code.into_iter());
 
         for ((name, arity), p) in self.pi_to_loc {
-            let entry = wam.indices.dynamic_code_dir.entry((name, arity))
+            let entry = wam.indices.dynamic_code_dir.entry((name.clone(), arity))
                            .or_insert(DynamicPredicateInfo::default());
+
             entry.clauses_subsection_p = p;
+            entry.module_src = name.owning_module();
         }
     }
 }
@@ -525,7 +527,7 @@ impl ListingCompiler {
                              -> Result<GatherResult, SessionError>
     {
         let flags      = wam.machine_flags();
-        let atom_tbl   = wam.indices.atom_tbl.clone();
+        let atom_tbl   = indices.atom_tbl.clone();
         let mut worker = TopLevelBatchWorker::new(src, atom_tbl.clone(), flags,
                                                   &mut wam.indices, &mut wam.policies,
                                                   &mut wam.code_repo);

src/prolog/machine/machine_errors.rs

@@ -66,7 +66,8 @@ impl MachineError {
     pub(super) fn session_error(h: usize, err: SessionError) -> Self {
         match err {
             SessionError::ParserError(err) => Self::syntax_error(h, err),
-            SessionError::CannotOverwriteBuiltIn(pred_str)
+            SessionError::CannotOverwriteDynamicClause(pred_str)
+          | SessionError::CannotOverwriteBuiltIn(pred_str)
           | SessionError::CannotOverwriteImport(pred_str) =>
                 Self::permission_error(PermissionError::Modify, pred_str),
             SessionError::ModuleDoesNotContainExport =>

src/prolog/machine/machine_indices.rs

@@ -365,14 +365,16 @@ impl AddAssign<usize> for CodePtr {
 pub type HeapVarDict  = HashMap<Rc<Var>, Addr>;
 pub type AllocVarDict = HashMap<Rc<Var>, VarData>;
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct DynamicPredicateInfo {
     pub(super) clauses_subsection_p: usize, // a LocalCodePtr::DirEntry value.
+    pub(super) module_src: ClauseName // the module the predicate is defined within.
 }
 
 impl Default for DynamicPredicateInfo {
     fn default() -> Self {
-        DynamicPredicateInfo { clauses_subsection_p: 0 }
+        DynamicPredicateInfo { clauses_subsection_p: 0,
+                               module_src: clause_name!("user") }
     }
 }
 
@@ -400,7 +402,8 @@ impl IndexStore {
                         module.code_dir.contains_key(&(name, arity)),
                     ClauseType::Op(op_decl, ..) =>
                         module.code_dir.contains_key(&(op_decl.name(), op_decl.arity())),
-                    _ => true
+                    _ =>
+                        true
                 },
             None =>
                 match ClauseType::from(name, arity, op_spec) {
@@ -408,7 +411,8 @@ impl IndexStore {
                         self.code_dir.contains_key(&(name, arity)),
                     ClauseType::Op(op_decl, ..) =>
                         self.code_dir.contains_key(&(op_decl.name(), op_decl.arity())),
-                    _ => true
+                    _ =>
+                        true
                 }
         }
     }

src/prolog/machine/modules.rs

@@ -71,7 +71,8 @@ pub trait SubModuleUser
 
     fn insert_dir_entry(&mut self, ClauseName, usize, ModuleCodeIndex);
 
-    fn remove_module(&mut self, mod_name: ClauseName, module: &Module) {
+    fn remove_module(&mut self, mod_name: ClauseName, module: &Module)
+    {
         for (name, arity) in module.module_decl.exports.iter().cloned() {
             let name = name.defrock_brackets();
 
@@ -83,6 +84,7 @@ pub trait SubModuleUser
 
                     self.remove_code_index((name.clone(), arity));
 
+
                     // remove or respecify ops.
                     if arity == 2 {
                         if let Some((_, _, mod_name)) = self.op_dir().get(&(name.clone(), Fixity::In)).cloned()
@@ -113,7 +115,8 @@ pub trait SubModuleUser
     }
 
     // returns true on successful import.
-    fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module) -> bool {
+    fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module) -> bool
+    {
         let name = name.defrock_brackets();
         let mut found_op = false;