Fix O(n²) performance issue in CLI datatype declaration processing

src/ast/datatype_decl_plugin.cpp

@@ -1076,14 +1076,13 @@ namespace datatype {
 
         sort * datatype = con->get_range();
         def const& d = get_def(datatype);
-        for (constructor const* c : d) {
-            if (c->name() == con->get_name()) {
-                for (accessor const* a : *c) {
-                    func_decl_ref fn = a->instantiate(datatype);
-                    res->push_back(fn);
-                    plugin().add_ast(fn);
-                }
-                break;
+        // Use O(1) lookup instead of O(n) linear search
+        constructor* c = d.get_constructor_by_name(con);
+        if (c) {
+            for (accessor const* a : *c) {
+                func_decl_ref fn = a->instantiate(datatype);
+                res->push_back(fn);
+                plugin().add_ast(fn);
             }
         }
         return res;
@@ -1105,13 +1104,11 @@ namespace datatype {
         sort * datatype = con->get_range();
         def const& dd = get_def(datatype);
         symbol r;
-        // This should be fixed for perf.
-        // Option 1: hash-table in dd that maps to constructors instead of iterating over all constructors.
-        // initialize the hash-table lazily when dd is large.
-        // Option 2: initialize all calls to plugin() registration in a single pass.
-        for (constructor const* c : dd) 
-            if (c->name() == con->get_name()) 
-                r = c->recognizer();                    
+        // Use O(1) lookup instead of O(n) linear search
+        constructor* c = dd.get_constructor_by_name(con);
+        if (c) {
+            r = c->recognizer();
+        }
         parameter ps[2] = { parameter(con), parameter(r) };
         d  = m.mk_func_decl(fid(), OP_DT_RECOGNISER, 2, ps, 1, &datatype);
         SASSERT(d);

src/ast/datatype_decl_plugin.h

@@ -26,6 +26,7 @@ Revision History:
 #include "util/buffer.h"
 #include "util/symbol_table.h"
 #include "util/obj_hashtable.h"
+#include "util/dictionary.h"
 
 
 enum sort_kind {
@@ -164,6 +165,7 @@ namespace datatype {
         sort_ref_vector         m_params;
         mutable sort_ref        m_sort;
         ptr_vector<constructor> m_constructors;
+        mutable dictionary<constructor*> m_name2constructor;
     public:
         def(ast_manager& m, util& u, symbol const& n, unsigned class_id, unsigned num_params, sort * const* params):
             m(m),
@@ -195,6 +197,31 @@ namespace datatype {
         util& u() const { return m_util; }
         param_size::size* sort_size() { return m_sort_size; }
         void set_sort_size(param_size::size* p) { auto* q = m_sort_size;  m_sort_size = p; if (p) p->inc_ref(); if (q) q->dec_ref(); m_sort = nullptr; }
+        constructor* get_constructor_by_name(func_decl* con) const {
+            symbol const& name = con->get_name();
+            constructor* result = nullptr;
+
+            // For small datatypes (< 10 constructors), use linear search instead of hash table
+            if (m_constructors.size() < 10) {
+                for (constructor* c : m_constructors) {
+                    if (c->name() == name) {
+                        result = c;
+                        break;
+                    }
+                }
+            } else {
+                // Lazy initialization of name-to-constructor map for O(1) lookups
+                if (m_name2constructor.empty() && !m_constructors.empty()) {
+                    for (constructor* c : m_constructors) {
+                        m_name2constructor.insert(c->name(), c);
+                    }
+                }
+                m_name2constructor.find(name, result);
+            }
+
+            SASSERT(result); // Post-condition: get_constructor_by_name returns a non-null result
+            return result;
+        }
         def* translate(ast_translation& tr, util& u);
     };