correct mismanagement of dynamic database across modules

src/prolog/machine/compile.rs

@@ -159,11 +159,12 @@ pub fn compile_term(wam: &mut Machine, packet: TopLevelPacket) -> EvalSession
 }
 
 pub(super)
-fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName, arity: usize)
+fn compile_into_module<R: Read>(wam: &mut Machine, module_name: ClauseName, src: R,
+                                name: ClauseName, arity: usize)
                                 -> EvalSession
 {
     let mut indices = default_index_store!(wam.atom_tbl_of(&name));
-    try_eval_session!(setup_indices(wam, name.owning_module(), &mut indices));
+    try_eval_session!(setup_indices(wam, module_name.clone(), &mut indices));
 
     let mut compiler = ListingCompiler::new(&wam.code_repo);
 
@@ -172,23 +173,23 @@ fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName, ari
                                                                &mut indices.code_dir, 0));
 
     let mut clause_code_generator = ClauseCodeGenerator::new(module_code.len());
-    try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map,
+    try_eval_session!(clause_code_generator.generate_clause_code(module_name.clone(),
+                                                                 results.dynamic_clause_map,
                                                                  wam));
 
-    match wam.indices.modules.get_mut(&name.owning_module()) {
+    match wam.indices.modules.get_mut(&module_name) {
         Some(module) => {
             let code_dir = mem::replace(&mut indices.code_dir, CodeDir::new());
             module.code_dir.extend(as_module_code_dir(code_dir));
 
             if module.module_decl.exports.contains(&(name.clone(), arity)) {
-                if let Some(idx) = wam.indices.code_dir.get(&(name.clone(), arity)) {                    
+                if let Some(idx) = wam.indices.code_dir.get(&(name.clone(), arity)) {
                     if module.module_decl.name == idx.0.borrow().1 {
-                        let module = module.module_decl.name.clone();
-
                         if module_code.len() > 0 {
-                            set_code_index!(idx, IndexPtr::Index(wam.code_repo.code.len()), module);
+                            set_code_index!(idx, IndexPtr::Index(wam.code_repo.code.len()),
+                                            module_name.clone());
                         } else {
-                            set_code_index!(idx, IndexPtr::Undefined, module);
+                            set_code_index!(idx, IndexPtr::Undefined, module_name.clone());
                         }
                     }
                 }
@@ -198,7 +199,7 @@ fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName, ari
     };
 
     wam.code_repo.code.extend(module_code.into_iter());
-    clause_code_generator.add_clause_code(wam);
+    clause_code_generator.add_clause_code(module_name, wam);
 
     EvalSession::EntrySuccess
 }
@@ -223,7 +224,8 @@ impl ClauseCodeGenerator {
         ClauseCodeGenerator { len_offset, code: vec![], pi_to_loc: HashMap::new() }
     }
 
-    fn generate_clause_code(&mut self, dynamic_clause_map: DynamicClauseMap, wam: &Machine)
+    fn generate_clause_code(&mut self, module: ClauseName, dynamic_clause_map: DynamicClauseMap,
+                            wam: &Machine)
                             -> Result<(), SessionError>
     {
         for ((name, arity), heads_and_tails) in dynamic_clause_map {
@@ -231,7 +233,7 @@ impl ClauseCodeGenerator {
                 continue;
             }
 
-            wam.check_dynamic_clause_overwrite(name.clone(), arity)?;
+            wam.check_dynamic_clause_overwrite(name.clone(), arity, module.clone())?;
 
             let predicate = Predicate(heads_and_tails.into_iter().map(|(head, tail)| {
                 let clause = Term::Clause(Cell::default(), clause_name!("clause"),
@@ -253,15 +255,15 @@ impl ClauseCodeGenerator {
         Ok(())
     }
 
-    fn add_clause_code(self, wam: &mut Machine) {
+    fn add_clause_code(self, module: ClauseName, wam: &mut Machine) {
         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.clone(), arity))
+            let entry = wam.indices.dynamic_code_dir.entry((name, arity))
                            .or_insert(DynamicPredicateInfo::default());
 
             entry.clauses_subsection_p = p;
-            entry.module_src = name.owning_module();
+            entry.module_src = module.clone();
         }
     }
 }
@@ -302,10 +304,10 @@ fn add_non_module_code(wam: &mut Machine, dynamic_clause_map: DynamicClauseMap,
     wam.check_toplevel_code(&indices, &dynamic_clause_map)?;
 
     let mut clause_code_generator = ClauseCodeGenerator::new(code.len());
-    clause_code_generator.generate_clause_code(dynamic_clause_map, wam)?;
+    clause_code_generator.generate_clause_code(clause_name!("user"), dynamic_clause_map, wam)?;
 
     add_toplevel_code(wam, code, indices);
-    clause_code_generator.add_clause_code(wam);
+    clause_code_generator.add_clause_code(clause_name!("user"), wam);
 
     Ok(())
 }
@@ -607,14 +609,17 @@ fn compile_work<R: Read>(compiler: &mut ListingCompiler, wam: &mut Machine, src:
 
     if let Some(module) = compiler.module.take() {
         let mut clause_code_generator = ClauseCodeGenerator::new(module_code.len() + toplvl_code.len());
+        let module_name = module.module_decl.name.clone();
 
         try_eval_session!(wam.check_toplevel_code(&results.toplevel_indices, &results.dynamic_clause_map));
-        try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map, wam));
+        try_eval_session!(clause_code_generator.generate_clause_code(module_name.clone(),
+                                                                     results.dynamic_clause_map,
+                                                                     wam));
 
         add_module_code(wam, module, module_code, indices);
         add_toplevel_code(wam, toplvl_code, results.toplevel_indices);
 
-        clause_code_generator.add_clause_code(wam);
+        clause_code_generator.add_clause_code(module_name, wam);
     } else {
         try_eval_session!(add_non_module_code(wam, results.dynamic_clause_map, module_code,
                                               indices));

src/prolog/machine/dynamic_database.rs

@@ -20,8 +20,18 @@ impl Machine {
     fn compile_into_machine<R: Read>(&mut self, src: R, name: ClauseName, arity: usize) -> EvalSession
     {
         match name.owning_module().as_str() {
-            "user" => compile_user_module(self, src),
+            "user" => match self.indices.code_dir.get(&(name.clone(), arity)).cloned() {
-            _ => compile_into_module(self, src, name, arity)
+                Some(idx) => {
+                    let module = idx.0.borrow().1.clone();
+
+                    match module.as_str() {
+                        "user" => compile_user_module(self, src),
+                        _ => compile_into_module(self, module, src, name, arity)
+                    }
+                },
+                None => compile_user_module(self, src)
+            },
+            _ => compile_into_module(self, name.owning_module(), src, name, arity)
         }
     }
 
@@ -76,7 +86,7 @@ impl Machine {
     {
         let (name, arity) = self.get_predicate_key(name, arity);
         let module_addr = self.machine_st[module].clone();
-        
+
         let module_name = match self.machine_st.store(self.machine_st.deref(module_addr)) {
             Addr::Con(Constant::Atom(module, _)) =>
                 match self.indices.modules.get_mut(&module) {
@@ -91,7 +101,7 @@ impl Machine {
                 },
             _ => unreachable!()
         };
-        
+
         if let Some(idx) = self.indices.code_dir.get(&(name.clone(), arity)) {
             if idx.module_name() == module_name {
                 set_code_index!(idx, IndexPtr::Undefined, clause_name!("user"));
@@ -100,7 +110,7 @@ impl Machine {
 
         self.indices.remove_code_index((name, arity));
     }
-    
+
     fn handle_eval_result_from_dynamic_compile(&mut self, pred_str: String, name: ClauseName,
                                                arity: usize, src: ClauseName)
     {
@@ -198,7 +208,7 @@ impl Machine {
             Addr::Con(Constant::Number(Number::Integer(n))) => n.to_usize().unwrap(),
             _ => unreachable!()
         };
-        
+
         let (name, arity) = self.get_predicate_key(temp_v!(1), temp_v!(2));
 
         self.retract_from_dynamic_predicate_impl(name, arity, index);

src/prolog/machine/mod.rs

@@ -211,11 +211,11 @@ impl Machine {
         self.machine_st.flags
     }
 
-    pub fn check_dynamic_clause_overwrite(&self, name: ClauseName, arity: usize)
+    pub fn check_dynamic_clause_overwrite(&self, name: ClauseName, arity: usize, module: ClauseName)
                                           -> Result<(), SessionError>
     {
         if let Some(info) = self.indices.dynamic_code_dir.get(&(name.clone(), arity)) {
-            if info.module_src != name.owning_module() {
+            if info.module_src != module {
                 let err_str = format!("{}/{}", name.as_str(), arity);
                 let err_str = clause_name!(err_str, self.indices.atom_tbl());
 
@@ -242,7 +242,8 @@ impl Machine {
             };
 
             if dynamic_clause_map.contains_key(&key) {
-                self.check_dynamic_clause_overwrite(key.0.clone(), key.1)?;
+                let module = idx.0.borrow().1.clone();
+                self.check_dynamic_clause_overwrite(key.0.clone(), key.1, module)?;
             }
             
             if let Some(ref existing_idx) = self.indices.code_dir.get(&key) {

src/prolog/machine/modules.rs

@@ -114,8 +114,7 @@ pub trait SubModuleUser
     }
 
     // returns true on successful import.
-    fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module)
+    fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module) -> bool
-                   -> bool
     {
         let name = name.defrock_brackets();
         let mut found_op = false;
@@ -134,14 +133,17 @@ pub trait SubModuleUser
             } else if arity == 2 {
                 insert_op_dir(Fixity::In);
             }
-        }
+        }        
 
         if let Some(code_data) = submodule.code_dir.get(&(name.clone(), arity)) {
-            let name = name.with_table(submodule.atom_tbl.clone());
+            let name = name.with_table(submodule.atom_tbl.clone());            
-
             let mut atom_tbl = self.atom_tbl();
+            
             atom_tbl.borrow_mut().insert(name.to_rc());
-
+            
+            let mut code_data = code_data.clone();
+            code_data.1 = submodule.module_decl.name.clone();
+            
             self.insert_dir_entry(name, arity, code_data.clone());
             true
         } else {
@@ -172,7 +174,8 @@ pub fn use_qualified_module<User>(user: &mut User, submodule: &Module, exports:
     Ok(())
 }
 
-pub fn use_module<User: SubModuleUser>(user: &mut User, submodule: &Module) -> Result<(), SessionError>
+pub fn use_module<User: SubModuleUser>(user: &mut User, submodule: &Module)
+                                       -> Result<(), SessionError>
 {
     for (name, arity) in submodule.module_decl.exports.iter().cloned() {
         if !user.import_decl(name, arity, submodule) {