Merge branch 'master' into library-use-case

src/machine/compile.rs

@@ -1258,7 +1258,7 @@ fn print_overwrite_warning(
         _ => {}
     }
 
-    println!("Warning: overwriting {}/{}", key.0.as_str(), key.1);
+    println!("Warning: overwriting {}/{} because the clauses are discontiguous", key.0.as_str(), key.1);
 }
 
 impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
@@ -2220,7 +2220,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
 
         let payload_compilation_target = self.payload.compilation_target;
 
-        let local_predicate_info = self
+        let mut local_predicate_info = self
             .wam_prelude
             .indices
             .get_local_predicate_skeleton(
@@ -2242,6 +2242,8 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
         let is_cross_module_clause =
             payload_compilation_target != self.payload.predicates.compilation_target;
 
+        local_predicate_info.is_discontiguous = predicate_info.is_discontiguous;
+
         if local_predicate_info.must_retract_local_clauses(is_cross_module_clause) {
             self.retract_local_clauses(&key, predicate_info.is_dynamic);
         }

src/machine/disjuncts.rs

@@ -530,7 +530,36 @@ impl VariableClassifier {
                         }
                     };
 
+                    let mut add_chunk = |classifier: &mut Self, name: Atom, terms: Vec<Term>| {
+                        if update_chunk_data(classifier, name, terms.len()) {
+                            build_stack.add_chunk();
+                        }
+
+                        for (arg_c, term) in terms.iter().enumerate() {
+                            classifier.probe_body_term(arg_c + 1, terms.len(), term);
+                        }
+
+                        build_stack.push_chunk_term(
+                            clause_to_query_term(
+                                loader,
+                                name,
+                                terms,
+                                classifier.call_policy,
+                            ),
+                        );
+                    };
+
                     match term {
+                        Term::Clause(_, name @ (atom!("->") | atom!(";") | atom!(",")), mut terms) if terms.len() == 3 => {
+                            if let Some(last_arg) = terms.last() {
+                                if let Term::Literal(_, Literal::CodeIndex(_)) = last_arg {
+                                    terms.pop();
+                                    state_stack.push(TraversalState::Term(Term::Clause(Cell::default(), name, terms)));
+                                } else {
+                                    add_chunk(self, name, terms);
+                                }
+                            }
+                        }
                         Term::Clause(_, atom!(","), mut terms) if terms.len() == 2 => {
                             let tail = terms.pop().unwrap();
                             let head = terms.pop().unwrap();
@@ -700,22 +729,7 @@ impl VariableClassifier {
                             self.call_policy = CallPolicy::Counted;
                         }
                         Term::Clause(_, name, terms) => {
-                            if update_chunk_data(self, name, terms.len()) {
-                                build_stack.add_chunk();
-                            }
-
-                            for (arg_c, term) in terms.iter().enumerate() {
-                                self.probe_body_term(arg_c + 1, terms.len(), term);
-                            }
-
-                            build_stack.push_chunk_term(
-                                clause_to_query_term(
-                                    loader,
-                                    name,
-                                    terms,
-                                    self.call_policy,
-                                ),
-                            );
+                            add_chunk(self, name, terms);
                         }
                         var @ Term::Var(..) => {
                             if update_chunk_data(self, atom!("call"), 1) {

src/machine/loader.rs

@@ -32,8 +32,7 @@ use std::ops::{Deref, DerefMut};
  * loader.pl does a few high-level things more easily handled from
  * Prolog that are not supported (or needed) during bootstrapping:
  * term and goal expansion, loading modules from different streams,
- * verifying certain kinds of declarations, perhaps (in the future?)
- * compiling inline disjunctions.
+ * and verifying certain kinds of declarations.
  *
  * Since the loader can operate incrementally, it uses an intermittent
  * structure to rebuild the loader between invocations. Preprocessor
@@ -1279,6 +1278,17 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
         name: Atom,
         arity: usize,
     ) -> Result<(), SessionError> {
+        let key = (name, arity);
+
+        let predicate_info = self
+            .wam_prelude
+            .indices
+            .get_predicate_skeleton(&self.payload.predicates.compilation_target, &key)
+            .map(|skeleton| skeleton.predicate_info())
+            .unwrap_or_default();
+
+        self.retract_local_clauses(&key, predicate_info.is_dynamic);
+
         self.add_extensible_predicate_declaration(
             compilation_target,
             name,

src/machine/term_stream.rs

@@ -9,6 +9,7 @@ use crate::read::devour_whitespace;
 
 use crate::predicate_queue;
 
+use fxhash::FxBuildHasher;
 use indexmap::IndexSet;
 
 use std::collections::VecDeque;
@@ -19,7 +20,7 @@ pub struct LoadStatePayload<TS> {
     pub(super) compilation_target: CompilationTarget,
     pub(super) retraction_info: RetractionInfo,
     pub(super) module_op_exports: ModuleOpExports,
-    pub(super) non_counted_bt_preds: IndexSet<PredicateKey>,
+    pub(super) non_counted_bt_preds: IndexSet<PredicateKey, FxBuildHasher>,
     pub(super) predicates: PredicateQueue,
     pub(super) clause_clauses: Vec<(Term, Term)>,
 }
@@ -97,10 +98,10 @@ impl<TS> LoadStatePayload<TS> {
             compilation_target: CompilationTarget::default(),
             retraction_info: RetractionInfo::new(code_repo_len),
             module_op_exports: vec![],
-            non_counted_bt_preds: IndexSet::new(),
+            non_counted_bt_preds: IndexSet::with_hasher(FxBuildHasher::default()),
             predicates: predicate_queue![],
             clause_clauses: vec![],
-        }
+         }
     }
 }