Merge pull request #1860 from waywardmonkeys/modernize-use-override

Use 'override' where possible.

src/muz/spacer/spacer_generalizers.cpp

@@ -50,7 +50,7 @@ namespace{
         contains_array_op_proc(ast_manager &manager) :
             m(manager), m_array_fid(m.mk_family_id("array"))
             {}
-        virtual bool operator()(expr *e) {
+        bool operator()(expr *e) override {
             return is_app(e) && to_app(e)->get_family_id() == m_array_fid;
         }
     };

src/muz/spacer/spacer_generalizers.h

@@ -117,11 +117,11 @@ class lemma_quantifier_generalizer : public lemma_generalizer {
     int m_offset;
 public:
     lemma_quantifier_generalizer(context &ctx, bool normalize_cube = true);
-    virtual ~lemma_quantifier_generalizer() {}
+    ~lemma_quantifier_generalizer() override {}
-    virtual void operator()(lemma_ref &lemma);
+    void operator()(lemma_ref &lemma) override;
 
-    virtual void collect_statistics(statistics& st) const;
+    void collect_statistics(statistics& st) const override;
-    virtual void reset_statistics() {m_st.reset();}
+    void reset_statistics() override {m_st.reset();}
 private:
     bool generalize(lemma_ref &lemma, app *term);
 

src/muz/transforms/dl_mk_synchronize.h

@@ -126,7 +126,7 @@ namespace datalog {
          */
         mk_synchronize(context & ctx, unsigned priority = 22500);
 
-        rule_set * operator()(rule_set const & source);
+        rule_set * operator()(rule_set const & source) override;
     };
 
 };

src/opt/maxres.cpp

@@ -144,7 +144,7 @@ public:
         }        
     }
 
-    virtual ~maxres() {}
+    ~maxres() override {}
 
     bool is_literal(expr* l) {
         return 
@@ -332,7 +332,7 @@ public:
     }
 
 
-    virtual lbool operator()() {
+    lbool operator()() override {
         m_defs.reset();
         switch(m_st) {
         case s_primal:
@@ -343,7 +343,7 @@ public:
         return l_undef;
     }
 
-    virtual void collect_statistics(statistics& st) const { 
+    void collect_statistics(statistics& st) const override {
         st.update("maxres-cores", m_stats.m_num_cores);
         st.update("maxres-correction-sets", m_stats.m_num_cs);
     }
@@ -781,7 +781,7 @@ public:
         TRACE("opt", tout << "after remove: " << asms << "\n";);
     }
 
-    virtual void updt_params(params_ref& _p) {
+    void updt_params(params_ref& _p) override {
         maxsmt_solver_base::updt_params(_p);
         opt_params p(_p);
         m_hill_climb =              p.maxres_hill_climb();
@@ -816,7 +816,7 @@ public:
         return l_true;
     }
 
-    virtual void commit_assignment() {
+    void commit_assignment() override {
         if (m_found_feasible_optimum) {
             TRACE("opt", tout << "Committing feasible solution\n" << m_defs << " " << m_asms;);
             s().assert_expr(m_defs);

src/opt/opt_cmds.cpp

@@ -56,33 +56,33 @@ public:
         m_opt(opt)
     {}
 
-    virtual ~assert_soft_cmd() {
+    ~assert_soft_cmd() override {
     }
 
-    virtual void reset(cmd_context & ctx) { 
+    void reset(cmd_context & ctx) override {
         m_idx = 0; 
         m_formula = nullptr;
     }
 
-    virtual char const * get_usage() const { return "<formula> [:weight <rational-weight>] [:id <symbol>]"; }
+    char const * get_usage() const override { return "<formula> [:weight <rational-weight>] [:id <symbol>]"; }
-    virtual char const * get_main_descr() const { return "assert soft constraint with optional weight and identifier"; }
+    char const * get_main_descr() const override { return "assert soft constraint with optional weight and identifier"; }
 
     // command invocation
-    virtual void prepare(cmd_context & ctx) {
+    void prepare(cmd_context & ctx) override {
         reset(ctx);
     }
 
-    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { 
+    cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
         if (m_idx == 0) return CPK_EXPR;
         return parametric_cmd::next_arg_kind(ctx);
     }
 
-    virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
+    void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
         p.insert("weight", CPK_NUMERAL, "(default: 1) penalty of not satisfying constraint.");
         p.insert("id", CPK_SYMBOL, "(default: null) partition identifier for soft constraints.");
     }
 
-    virtual void set_next_arg(cmd_context & ctx, expr * t) {
+    void set_next_arg(cmd_context & ctx, expr * t) override {
         SASSERT(m_idx == 0);
         if (!ctx.m().is_bool(t)) {
             throw cmd_exception("Invalid type for expression. Expected Boolean type.");
@@ -91,11 +91,11 @@ public:
         ++m_idx;
     }
 
-    virtual void failure_cleanup(cmd_context & ctx) {
+    void failure_cleanup(cmd_context & ctx) override {
         reset(ctx);
     }
 
-    virtual void execute(cmd_context & ctx) {
+    void execute(cmd_context & ctx) override {
         if (!m_formula) {
             throw cmd_exception("assert-soft requires a formulas as argument.");
         }
@@ -107,7 +107,7 @@ public:
         reset(ctx);
     }
 
-    virtual void finalize(cmd_context & ctx) { 
+    void finalize(cmd_context & ctx) override {
     }
 
 };
@@ -123,14 +123,14 @@ public:
         m_opt(opt)
     {}
 
-    virtual void reset(cmd_context & ctx) { }
+    void reset(cmd_context & ctx) override { }
-    virtual char const * get_usage() const { return "<term>"; }
+    char const * get_usage() const override { return "<term>"; }
-    virtual char const * get_descr(cmd_context & ctx) const { return "check sat modulo objective function";}
+    char const * get_descr(cmd_context & ctx) const override { return "check sat modulo objective function";}
-    virtual unsigned get_arity() const { return 1; }
+    unsigned get_arity() const override { return 1; }
-    virtual void prepare(cmd_context & ctx) {}
+    void prepare(cmd_context & ctx) override {}
-    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_EXPR; }
+    cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_EXPR; }
 
-    virtual void set_next_arg(cmd_context & ctx, expr * t) {
+    void set_next_arg(cmd_context & ctx, expr * t) override {
         if (!is_app(t)) {
             throw cmd_exception("malformed objective term: it cannot be a quantifier or bound variable");
         }
@@ -138,11 +138,11 @@ public:
         ctx.print_success();
     }
 
-    virtual void failure_cleanup(cmd_context & ctx) {
+    void failure_cleanup(cmd_context & ctx) override {
         reset(ctx);
     }
 
-    virtual void execute(cmd_context & ctx) {
+    void execute(cmd_context & ctx) override {
     }
 };
 
@@ -154,18 +154,18 @@ public:
         m_opt(opt)
     {}
     
-    virtual void reset(cmd_context & ctx) { }
+    void reset(cmd_context & ctx) override { }
-    virtual char const * get_usage() const { return "(get-objectives)"; }
+    char const * get_usage() const override { return "(get-objectives)"; }
-    virtual char const * get_descr(cmd_context & ctx) const { return "retrieve the objective values (after optimization)"; }
+    char const * get_descr(cmd_context & ctx) const override { return "retrieve the objective values (after optimization)"; }
-    virtual unsigned get_arity() const { return 0; }
+    unsigned get_arity() const override { return 0; }
-    virtual void prepare(cmd_context & ctx) {}
+    void prepare(cmd_context & ctx) override {}
 
 
-    virtual void failure_cleanup(cmd_context & ctx) {
+    void failure_cleanup(cmd_context & ctx) override {
         reset(ctx);
     }
 
-    virtual void execute(cmd_context & ctx) {
+    void execute(cmd_context & ctx) override {
         if (!ctx.ignore_check()) {
             get_opt(ctx, m_opt).display_assignment(ctx.regular_stream());        
         }

src/opt/sortmax.cpp

@@ -39,9 +39,9 @@ namespace opt {
         sortmax(maxsat_context& c, weights_t& ws, expr_ref_vector const& soft): 
             maxsmt_solver_base(c, ws, soft), m_sort(*this), m_trail(m), m_fresh(m) {}
 
-        virtual ~sortmax() {}
+        ~sortmax() override {}
 
-        lbool operator()() {
+        lbool operator()() override {
             obj_map<expr, rational> soft;            
             if (!init()) {
                 return l_false;

src/opt/wmax.cpp

@@ -49,9 +49,9 @@ namespace opt {
             m_trail(m),
             m_defs(m) {}
 
-        virtual ~wmax() {}
+        ~wmax() override {}
 
-        lbool operator()() {
+        lbool operator()() override {
             TRACE("opt", tout << "weighted maxsat\n";);
             scoped_ensure_theory wth(*this);
             obj_map<expr, rational> soft;            

src/sat/ba_solver.h

@@ -128,7 +128,7 @@ namespace sat {
             virtual void set_k(unsigned k) { VERIFY(k < 4000000000);  m_k = k; }
             virtual unsigned get_coeff(unsigned i) const { UNREACHABLE(); return 0; }
             unsigned k() const { return m_k; }
-            virtual bool well_formed() const;
+            bool well_formed() const override;
         };
 
         class card : public pb_base {
@@ -140,13 +140,13 @@ namespace sat {
             literal& operator[](unsigned i) { return m_lits[i]; }
             literal const* begin() const { return m_lits; }
             literal const* end() const { return static_cast<literal const*>(m_lits) + m_size; }
-            virtual void negate();                     
+            void negate() override;
-            virtual void swap(unsigned i, unsigned j) { std::swap(m_lits[i], m_lits[j]); }
+            void swap(unsigned i, unsigned j) override { std::swap(m_lits[i], m_lits[j]); }
-            virtual literal_vector literals() const { return literal_vector(m_size, m_lits); }            
+            literal_vector literals() const override { return literal_vector(m_size, m_lits); }
-            virtual bool is_watching(literal l) const;
+            bool is_watching(literal l) const override;
-            virtual literal get_lit(unsigned i) const { return m_lits[i]; }
+            literal get_lit(unsigned i) const override { return m_lits[i]; }
-            virtual void set_lit(unsigned i, literal l) { m_lits[i] = l; }
+            void set_lit(unsigned i, literal l) override { m_lits[i] = l; }
-            virtual unsigned get_coeff(unsigned i) const { return 1; }
+            unsigned get_coeff(unsigned i) const override { return 1; }
         };
 
         
@@ -173,14 +173,14 @@ namespace sat {
             void update_max_sum();
             void set_num_watch(unsigned s) { m_num_watch = s; }
             bool is_cardinality() const;
-            virtual void negate();                       
+            void negate() override;
-            virtual void set_k(unsigned k) { m_k = k; VERIFY(k < 4000000000); update_max_sum(); }
+            void set_k(unsigned k) override { m_k = k; VERIFY(k < 4000000000); update_max_sum(); }
-            virtual void swap(unsigned i, unsigned j) { std::swap(m_wlits[i], m_wlits[j]); }
+            void swap(unsigned i, unsigned j) override { std::swap(m_wlits[i], m_wlits[j]); }
-            virtual literal_vector literals() const { literal_vector lits; for (auto wl : *this) lits.push_back(wl.second); return lits; }
+            literal_vector literals() const override { literal_vector lits; for (auto wl : *this) lits.push_back(wl.second); return lits; }
-            virtual bool is_watching(literal l) const;
+            bool is_watching(literal l) const override;
-            virtual literal get_lit(unsigned i) const { return m_wlits[i].second; }
+            literal get_lit(unsigned i) const override { return m_wlits[i].second; }
-            virtual void set_lit(unsigned i, literal l) { m_wlits[i].second = l; }
+            void set_lit(unsigned i, literal l) override { m_wlits[i].second = l; }
-            virtual unsigned get_coeff(unsigned i) const { return m_wlits[i].first; }
+            unsigned get_coeff(unsigned i) const override { return m_wlits[i].first; }
         };
 
         class xr : public constraint {
@@ -191,13 +191,13 @@ namespace sat {
             literal operator[](unsigned i) const { return m_lits[i]; }
             literal const* begin() const { return m_lits; }
             literal const* end() const { return begin() + m_size; }
-            virtual void negate() { m_lits[0].neg(); }
+            void negate() override { m_lits[0].neg(); }
-            virtual void swap(unsigned i, unsigned j) { std::swap(m_lits[i], m_lits[j]); }
+            void swap(unsigned i, unsigned j) override { std::swap(m_lits[i], m_lits[j]); }
-            virtual bool is_watching(literal l) const;
+            bool is_watching(literal l) const override;
-            virtual literal_vector literals() const { return literal_vector(size(), begin()); }
+            literal_vector literals() const override { return literal_vector(size(), begin()); }
-            virtual literal get_lit(unsigned i) const { return m_lits[i]; }
+            literal get_lit(unsigned i) const override { return m_lits[i]; }
-            virtual void set_lit(unsigned i, literal l) { m_lits[i] = l; }
+            void set_lit(unsigned i, literal l) override { m_lits[i] = l; }
-            virtual bool well_formed() const;
+            bool well_formed() const override;
         };
 
 
@@ -484,44 +484,44 @@ namespace sat {
 
     public:
         ba_solver();
-        virtual ~ba_solver();
+        ~ba_solver() override;
-        virtual void set_solver(solver* s) { m_solver = s; }
+        void set_solver(solver* s) override { m_solver = s; }
-        virtual void set_lookahead(lookahead* l) { m_lookahead = l; }
+        void set_lookahead(lookahead* l) override { m_lookahead = l; }
-        virtual void set_unit_walk(unit_walk* u) { m_unit_walk = u; }
+        void set_unit_walk(unit_walk* u) override { m_unit_walk = u; }
         void    add_at_least(bool_var v, literal_vector const& lits, unsigned k);
         void    add_pb_ge(bool_var v, svector<wliteral> const& wlits, unsigned k);
         void    add_xr(literal_vector const& lits);
 
-        virtual bool propagate(literal l, ext_constraint_idx idx);
+        bool propagate(literal l, ext_constraint_idx idx) override;
-        virtual lbool resolve_conflict();
+        lbool resolve_conflict() override;
-        virtual void get_antecedents(literal l, ext_justification_idx idx, literal_vector & r);
+        void get_antecedents(literal l, ext_justification_idx idx, literal_vector & r) override;
-        virtual void asserted(literal l);
+        void asserted(literal l) override;
-        virtual check_result check();
+        check_result check() override;
-        virtual void push();
+        void push() override;
-        virtual void pop(unsigned n);
+        void pop(unsigned n) override;
-        virtual void simplify();
+        void simplify() override;
-        virtual void clauses_modifed();
+        void clauses_modifed() override;
-        virtual lbool get_phase(bool_var v);
+        lbool get_phase(bool_var v) override;
-        virtual bool set_root(literal l, literal r);
+        bool set_root(literal l, literal r) override;
-        virtual void flush_roots();
+        void flush_roots() override;
-        virtual std::ostream& display(std::ostream& out) const;
+        std::ostream& display(std::ostream& out) const override;
-        virtual std::ostream& display_justification(std::ostream& out, ext_justification_idx idx) const;
+        std::ostream& display_justification(std::ostream& out, ext_justification_idx idx) const override;
-        virtual void collect_statistics(statistics& st) const;
+        void collect_statistics(statistics& st) const override;
-        virtual extension* copy(solver* s);
+        extension* copy(solver* s) override;
-        virtual extension* copy(lookahead* s, bool learned);
+        extension* copy(lookahead* s, bool learned) override;
-        virtual void find_mutexes(literal_vector& lits, vector<literal_vector> & mutexes);
+        void find_mutexes(literal_vector& lits, vector<literal_vector> & mutexes) override;
-        virtual void pop_reinit();
+        void pop_reinit() override;
-        virtual void gc(); 
+        void gc() override;
-        virtual double get_reward(literal l, ext_justification_idx idx, literal_occs_fun& occs) const;
+        double get_reward(literal l, ext_justification_idx idx, literal_occs_fun& occs) const override;
-        virtual bool is_extended_binary(ext_justification_idx idx, literal_vector & r);
+        bool is_extended_binary(ext_justification_idx idx, literal_vector & r) override;
-        virtual void init_use_list(ext_use_list& ul);
+        void init_use_list(ext_use_list& ul) override;
-        virtual bool is_blocked(literal l, ext_constraint_idx idx);
+        bool is_blocked(literal l, ext_constraint_idx idx) override;
-        virtual bool check_model(model const& m) const;
+        bool check_model(model const& m) const override;
 
         ptr_vector<constraint> const & constraints() const { return m_constraints; }
         void display(std::ostream& out, constraint const& c, bool values) const;
 
-        virtual bool validate();
+        bool validate() override;
 
 
     };

src/sat/sat_lookahead.cpp

@@ -1217,7 +1217,7 @@ namespace sat {
         lookahead& lh;
     public:
         lookahead_literal_occs_fun(lookahead& lh): lh(lh) {}
-        double operator()(literal l) { return lh.literal_occs(l); }
+        double operator()(literal l) override { return lh.literal_occs(l); }
     };
 
     // Ternary clause managagement:

src/sat/tactic/goal2sat.h

@@ -86,7 +86,7 @@ public:
         
     public:
         mc(ast_manager& m);
-        virtual ~mc() {}
+        ~mc() override {}
         // flush model converter from SAT solver to this structure.
         void flush_smc(sat::solver& s, atom2bool_var const& map);         
         void operator()(model_ref& md) override;

src/smt/theory_lra.cpp

@@ -147,7 +147,7 @@ class theory_lra::imp {
         imp& m_imp;
     public:
         resource_limit(imp& i): m_imp(i) { }
-        virtual bool get_cancel_flag() { return m_imp.m.canceled(); }
+        bool get_cancel_flag() override { return m_imp.m.canceled(); }
     };
 
 

src/smt/theory_pb.cpp

@@ -759,18 +759,18 @@ namespace smt {
 
         card& get_card() { return m_card; }
 
-        virtual void get_antecedents(conflict_resolution& cr) {
+        void get_antecedents(conflict_resolution& cr) override {
             cr.mark_literal(m_card.lit());
             for (unsigned i = m_card.k(); i < m_card.size(); ++i) {
                 cr.mark_literal(~m_card.lit(i));
             }
         }
 
-        virtual theory_id get_from_theory() const {
+        theory_id get_from_theory() const override {
             return m_fid;
         }
         
-        virtual proof* mk_proof(smt::conflict_resolution& cr) { 
+        proof* mk_proof(smt::conflict_resolution& cr) override {
             ptr_buffer<proof> prs;
             ast_manager& m = cr.get_context().get_manager(); 
             expr_ref fact(m);

src/smt/theory_str.cpp

@@ -110,7 +110,7 @@ namespace smt {
     public:
         seq_expr_solver(ast_manager& m, smt_params& fp):
             m_kernel(m, fp) {}
-        virtual lbool check_sat(expr* e) {
+        lbool check_sat(expr* e) override {
             m_kernel.push();
             m_kernel.assert_expr(e);
             lbool r = m_kernel.check();

src/solver/parallel_tactic.cpp

@@ -672,7 +672,7 @@ public:
         init();
     }
 
-    void operator ()(const goal_ref & g,goal_ref_buffer & result) {
+    void operator ()(const goal_ref & g,goal_ref_buffer & result) override {
         fail_if_proof_generation("parallel-tactic", g);
         ast_manager& m = g->m();        
         solver* s = m_solver->translate(m, m_params);
@@ -719,29 +719,29 @@ public:
         return pp.conquer_batch_size();
     }
 
-    void cleanup() {
+    void cleanup() override {
         m_queue.reset();
     }
 
-    tactic* translate(ast_manager& m) {
+    tactic* translate(ast_manager& m) override {
         solver* s = m_solver->translate(m, m_params);
         return alloc(parallel_tactic, s, m_params);
     }
 
-    virtual void updt_params(params_ref const & p) {
+    void updt_params(params_ref const & p) override {
         m_params.copy(p);
         parallel_params pp(p);
         m_conquer_delay = pp.conquer_delay();
     }
 
-    virtual void collect_statistics(statistics & st) const {
+    void collect_statistics(statistics & st) const override {
         st.copy(m_stats);
         st.update("par unsat", m_num_unsat);
         st.update("par models", m_models.size());
         st.update("par progress", m_progress);
     }
 
-    virtual void reset_statistics() {
+    void reset_statistics() override {
         m_stats.reset();
     }
 };

src/tactic/core/symmetry_reduce_tactic.cpp

@@ -40,7 +40,7 @@ public:
     
     void operator()(goal_ref const & g, 
                     goal_ref_buffer & result) override;
-    virtual void cleanup() override;
+    void cleanup() override;
 };
 
 class ac_rewriter {

src/tactic/dependency_converter.cpp

@@ -27,15 +27,15 @@ public:
     
     unit_dependency_converter(expr_dependency_ref& d) : m_dep(d) {}
 
-    virtual expr_dependency_ref operator()() { return m_dep; }
+    expr_dependency_ref operator()() override { return m_dep; }
     
-    virtual dependency_converter * translate(ast_translation & translator) {
+    dependency_converter * translate(ast_translation & translator) override {
         expr_dependency_translation tr(translator);
         expr_dependency_ref d(tr(m_dep), translator.to());
         return alloc(unit_dependency_converter, d);
     }
 
-    virtual void display(std::ostream& out) {
+    void display(std::ostream& out) override {
         out << m_dep.get() << "\n";
     }
 };
@@ -47,18 +47,18 @@ public:
     
     concat_dependency_converter(dependency_converter* c1, dependency_converter* c2) : m_dc1(c1), m_dc2(c2) {}
 
-    virtual expr_dependency_ref operator()() { 
+    expr_dependency_ref operator()() override {
         expr_dependency_ref d1 = (*m_dc1)();
         expr_dependency_ref d2 = (*m_dc2)();
         ast_manager& m = d1.get_manager();
         return expr_dependency_ref(m.mk_join(d1, d2), m);
     }
     
-    virtual dependency_converter * translate(ast_translation & translator) {
+    dependency_converter * translate(ast_translation & translator) override {
         return alloc(concat_dependency_converter, m_dc1->translate(translator), m_dc2->translate(translator));
     }
 
-    virtual void display(std::ostream& out) {
+    void display(std::ostream& out) override {
         m_dc1->display(out);
         m_dc2->display(out);
     }
@@ -73,7 +73,7 @@ public:
         for (unsigned i = 0; i < n; ++i) m_goals.push_back(goals[i]);
     }
 
-    virtual expr_dependency_ref operator()() { 
+    expr_dependency_ref operator()() override {
         expr_dependency_ref result(m.mk_empty_dependencies(), m);
         for (goal_ref g : m_goals) {
             dependency_converter_ref dc = g->dc();
@@ -81,13 +81,13 @@ public:
         }
         return result;
     }    
-    virtual dependency_converter * translate(ast_translation & translator) {
+    dependency_converter * translate(ast_translation & translator) override {
         goal_ref_buffer goals;
         for (goal_ref g : m_goals) goals.push_back(g->translate(translator));
         return alloc(goal_dependency_converter, goals.size(), goals.c_ptr());
     }
 
-    virtual void display(std::ostream& out) { out << "goal-dep\n"; }
+    void display(std::ostream& out) override { out << "goal-dep\n"; }
 
 };
 

src/tactic/generic_model_converter.h

@@ -41,7 +41,7 @@ class generic_model_converter : public model_converter {
 public:
     generic_model_converter(ast_manager & m, char const* orig) : m(m), m_orig(orig) {}
     
-    virtual ~generic_model_converter();
+    ~generic_model_converter() override;
     
     void hide(expr* e) { SASSERT(is_app(e) && to_app(e)->get_num_args() == 0); hide(to_app(e)->get_decl()); }
 

src/tactic/tactical.cpp

@@ -744,7 +744,7 @@ public:
         SASSERT(t);  
     }    
 
-    virtual ~unary_tactical() { }
+    ~unary_tactical() override { }
 
     void operator()(goal_ref const & in, goal_ref_buffer& result) override { 
         m_t->operator()(in, result);
@@ -1003,7 +1003,7 @@ public:
         SASSERT(m_p);
     }
 
-    virtual ~cond_tactical() {}
+    ~cond_tactical() override {}
     
     void operator()(goal_ref const & in, goal_ref_buffer & result) override {
         if (m_p->operator()(*(in.get())).is_true()) 
@@ -1035,7 +1035,7 @@ public:
         SASSERT(m_p);
     }
     
-    virtual ~fail_if_tactic() {}
+    ~fail_if_tactic() override {}
 
     void cleanup() override {}
 

src/util/lp/lar_solver.h

@@ -397,7 +397,7 @@ public:
 
     column_type get_column_type(unsigned j) const;
 
-    std::string get_column_name(unsigned j) const;
+    std::string get_column_name(unsigned j) const override;
 
     bool all_constrained_variables_are_registered(const vector<std::pair<mpq, var_index>>& left_side);