prepare user propagator declared functions for likely Clemens use case

src/smt/smt_context.h

@@ -1728,6 +1728,18 @@ namespace smt {
                 throw default_exception("user propagator must be initialized");
             return m_user_propagator->add_expr(e);
         }
+
+        void user_propagate_register_declared(user_propagator::register_created_eh_t& r) {
+            if (!m_user_propagator)
+                throw default_exception("user propagator must be initialized");
+            m_user_propagator->register_declared(r);
+        }
+
+        func_decl* user_propagate_declare(symbol const& name, unsigned n, sort* const* domain, sort* range) {
+            if (!m_user_propagator)
+                throw default_exception("user propagator must be initialized");
+            return m_user_propagator->declare(name, n, domain, range);
+        }
         
         bool watches_fixed(enode* n) const;
 

src/smt/smt_kernel.cpp

@@ -248,6 +248,14 @@ namespace smt {
         unsigned user_propagate_register(expr* e) {
             return m_kernel.user_propagate_register(e);
         }
+
+        void user_propagate_register_declared(user_propagator::register_created_eh_t& r) {
+            m_kernel.user_propagate_register_declared(r);
+        }
+
+        func_decl* user_propagate_declare(symbol const& name, unsigned n, sort* const* domain, sort* range) {
+            return m_kernel.user_propagate_declare(name, n, domain, range);
+        }
         
     };
 
@@ -477,4 +485,12 @@ namespace smt {
         return m_imp->user_propagate_register(e);
     }        
 
-};
+    void kernel::user_propagate_register_declared(user_propagator::register_created_eh_t& r) {
+        m_imp->user_propagate_register_declared(r);
+    }
+
+    func_decl* kernel::user_propagate_declare(symbol const& name, unsigned n, sort* const* domain, sort* range) {
+        return m_imp->user_propagate_declare(name, n, domain, range);
+    }
+
+};

src/smt/smt_kernel.h

@@ -301,12 +301,11 @@ namespace smt {
         
         void user_propagate_register_diseq(user_propagator::eq_eh_t& diseq_eh);
 
-
-        /**
-           \brief register an expression to be tracked fro user propagation.
-        */
         unsigned user_propagate_register(expr* e);
         
+        void user_propagate_register_declared(user_propagator::register_created_eh_t& r);
+
+        func_decl* user_propagate_declare(symbol const& name, unsigned n, sort* const* domain, sort* range);
 
         /**
            \brief Return a reference to smt::context.

src/smt/theory_user_propagator.cpp

@@ -173,6 +173,26 @@ void theory_user_propagator::propagate() {
     m_qhead = qhead;
 }
 
+func_decl* theory_user_propagator::declare(symbol const& name, unsigned n, sort* const* domain, sort* range) {
+    if (!m_created_eh)
+        throw default_exception("event handler for dynamic expressions has to be registered before functions can be created");
+    // ensure that declaration plugin is registered with m.
+    if (!m.has_plugin(get_id())) 
+        m.register_plugin(get_id(), alloc(user_propagator::plugin));
+    
+    func_decl_info info(get_id(), user_propagator::plugin::kind_t::OP_USER_PROPAGATE);
+    return m.mk_func_decl(name, n, domain, range, info);    
+}
+
+bool theory_user_propagator::internalize_atom(app* atom, bool gate_ctx) {
+    return internalize_term(atom);
+}
+
+bool theory_user_propagator::internalize_term(app* term)  { 
+    NOT_IMPLEMENTED_YET();
+    return false;    
+}
+
 void theory_user_propagator::collect_statistics(::statistics & st) const {
     st.update("user-propagations", m_stats.m_num_propagations);
     st.update("user-watched",      get_num_vars());

src/smt/theory_user_propagator.h

@@ -56,6 +56,8 @@ namespace smt {
         user_propagator::fixed_eh_t     m_fixed_eh;
         user_propagator::eq_eh_t        m_eq_eh;
         user_propagator::eq_eh_t        m_diseq_eh;
+        user_propagator::register_created_eh_t m_created_eh;
+
         user_propagator::context_obj*   m_api_context = nullptr;
         unsigned               m_qhead = 0;
         uint_set               m_fixed;
@@ -94,6 +96,8 @@ namespace smt {
         void register_fixed(user_propagator::fixed_eh_t& fixed_eh) { m_fixed_eh = fixed_eh; }
         void register_eq(user_propagator::eq_eh_t& eq_eh) { m_eq_eh = eq_eh; }
         void register_diseq(user_propagator::eq_eh_t& diseq_eh) { m_diseq_eh = diseq_eh; }
+        void register_declared(user_propagator::register_created_eh_t& created_eh) { m_created_eh = created_eh; }
+        func_decl* declare(symbol const& name, unsigned n, sort* const* domain, sort* range);
 
         bool has_fixed() const { return (bool)m_fixed_eh; }
 
@@ -103,8 +107,8 @@ namespace smt {
         void new_fixed_eh(theory_var v, expr* value, unsigned num_lits, literal const* jlits);
 
         theory * mk_fresh(context * new_ctx) override;
-        bool internalize_atom(app * atom, bool gate_ctx) override { UNREACHABLE(); return false; }
-        bool internalize_term(app * term) override { UNREACHABLE(); return false; }
+        bool internalize_atom(app* atom, bool gate_ctx) override;
+        bool internalize_term(app* term) override;
         void new_eq_eh(theory_var v1, theory_var v2) override { if (m_eq_eh) m_eq_eh(m_user_context, this, v1, v2); }
         void new_diseq_eh(theory_var v1, theory_var v2) override { if (m_diseq_eh) m_diseq_eh(m_user_context, this, v1, v2); }
         bool use_diseqs() const override { return ((bool)m_diseq_eh); }