From e70dcf2112602446932a45b4695e5b6afc11679a Mon Sep 17 00:00:00 2001 From: Michael Tautschnig Date: Sat, 23 Mar 2019 12:25:22 +0000 Subject: [PATCH] Add the deprecation date to each deprecated entity This makes the date of deprecation visible in warning messages and also makes tracking much easier: git grep DEPRECATED or any code review will yield immediate insight on how long an entity has been deprecated already. The date is taken from the commit that first marked the entity as deprecated. --- src/goto-instrument/cover.cpp | 2 +- src/goto-programs/goto_function.h | 8 +- src/goto-programs/goto_program.h | 49 +++-- src/goto-programs/link_to_library.h | 2 +- src/goto-symex/ssa_step.h | 2 +- .../strings/string_constraint_generator.h | 3 +- ...string_constraint_generator_comparison.cpp | 2 +- .../string_constraint_generator_insert.cpp | 8 +- .../string_constraint_generator_main.cpp | 2 +- .../string_constraint_generator_testing.cpp | 5 +- .../string_constraint_generator_valueof.cpp | 8 +- src/util/arith_tools.h | 2 +- src/util/base_type.h | 4 +- src/util/byte_operators.h | 6 +- src/util/deprecate.h | 3 + src/util/expr.h | 18 +- src/util/lispexpr.h | 3 +- src/util/mathematical_expr.h | 9 +- src/util/message.h | 2 +- src/util/mp_arith.h | 7 +- src/util/std_code.h | 79 ++++--- src/util/std_expr.h | 204 ++++++++++-------- src/util/std_types.h | 9 +- src/util/string_expr.h | 6 +- src/util/type.h | 8 +- 25 files changed, 264 insertions(+), 187 deletions(-) diff --git a/src/goto-instrument/cover.cpp b/src/goto-instrument/cover.cpp index 206109e2fa1..dfe80ef25bc 100644 --- a/src/goto-instrument/cover.cpp +++ b/src/goto-instrument/cover.cpp @@ -58,7 +58,7 @@ void instrument_cover_goals( /// \deprecated use instrument_cover_goals(goto_programt &goto_program, /// const cover_instrumenterst &instrumenters, /// message_handlert &message_handler, const irep_idt mode) instead -DEPRECATED("use instrument_cover_goals(goto_programt &...) instead") +DEPRECATED(SINCE(2018, 2, 9, "use instrument_cover_goals goto_programt &...")) void instrument_cover_goals( const symbol_tablet &symbol_table, const irep_idt &function_id, diff --git a/src/goto-programs/goto_function.h b/src/goto-programs/goto_function.h index 90ef0d7879c..da6d0d35a5e 100644 --- a/src/goto-programs/goto_function.h +++ b/src/goto-programs/goto_function.h @@ -30,7 +30,7 @@ class goto_functiont goto_programt body; /// The type of the function, indicating the return type and parameter types - DEPRECATED("Get the type from the symbol table instead") + DEPRECATED(SINCE(2019, 2, 16, "Get the type from the symbol table instead")) code_typet type; typedef std::vector parameter_identifierst; @@ -54,19 +54,19 @@ class goto_functiont parameter_identifiers.push_back(parameter.get_identifier()); } - DEPRECATED("Get the type from the symbol table instead") + DEPRECATED(SINCE(2019, 2, 16, "Get the type from the symbol table instead")) bool is_inlined() const { return type.get_bool(ID_C_inlined); } - DEPRECATED("Get the type from the symbol table instead") + DEPRECATED(SINCE(2019, 2, 16, "Get the type from the symbol table instead")) bool is_hidden() const { return type.get_bool(ID_C_hide); } - DEPRECATED("Get the type from the symbol table instead") + DEPRECATED(SINCE(2019, 2, 16, "Get the type from the symbol table instead")) void make_hidden() { type.set(ID_C_hide, true); diff --git a/src/goto-programs/goto_program.h b/src/goto-programs/goto_program.h index 701ee9f9d85..ea53dc3ac36 100644 --- a/src/goto-programs/goto_program.h +++ b/src/goto-programs/goto_program.h @@ -353,64 +353,71 @@ class goto_programt clear(SKIP); } - DEPRECATED("use goto_programt::make_return() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_return() instead")) void make_return() { clear(RETURN); } - DEPRECATED("use goto_programt::make_skip() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_skip() instead")) void make_skip() { clear(SKIP); } - DEPRECATED("use goto_programt::make_location() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_location() instead")) void make_location(const source_locationt &l) { clear(LOCATION); source_location=l; } - DEPRECATED("use goto_programt::make_throw() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_throw() instead")) void make_throw() { clear(THROW); } - DEPRECATED("use goto_programt::make_catch() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_catch() instead")) void make_catch() { clear(CATCH); } - DEPRECATED("use goto_programt::make_assertion() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_assertion() instead")) void make_assertion(const exprt &g) { clear(ASSERT); guard=g; } - DEPRECATED("use goto_programt::make_assumption() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_assumption() instead")) void make_assumption(const exprt &g) { clear(ASSUME); guard=g; } - DEPRECATED("use goto_programt::make_assignment() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_assignment() instead")) void make_assignment() { clear(ASSIGN); } - DEPRECATED("use goto_programt::make_other() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_other() instead")) void make_other(const codet &_code) { clear(OTHER); code=_code; } - DEPRECATED("use goto_programt::make_decl() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_decl() instead")) void make_decl() { clear(DECL); } - DEPRECATED("use goto_programt::make_dead() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_dead() instead")) void make_dead() { clear(DEAD); } - DEPRECATED("use goto_programt::make_atomic_begin() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_atomic_begin() instead")) void make_atomic_begin() { clear(ATOMIC_BEGIN); } - DEPRECATED("use goto_programt::make_atomic_end() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_atomic_end() instead")) void make_atomic_end() { clear(ATOMIC_END); } - DEPRECATED("use goto_programt::make_end_function() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_end_function() instead")) void make_end_function() { clear(END_FUNCTION); } - DEPRECATED("use goto_programt::make_incomplete_goto() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_incomplete_goto() instead")) void make_incomplete_goto(const code_gotot &_code) { clear(INCOMPLETE_GOTO); code = _code; } - DEPRECATED("use goto_programt::make_goto() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_goto() instead")) void make_goto(targett _target) { clear(GOTO); targets.push_back(_target); } - DEPRECATED("use goto_programt::make_goto() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_goto() instead")) void make_goto(targett _target, const exprt &g) { make_goto(_target); @@ -425,21 +432,23 @@ class goto_programt type = GOTO; } - DEPRECATED("use goto_programt::make_assignment() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_assignment() instead")) void make_assignment(const code_assignt &_code) { clear(ASSIGN); code=_code; } - DEPRECATED("use goto_programt::make_decl() instead") + DEPRECATED(SINCE(2019, 2, 13, "use goto_programt::make_decl() instead")) void make_decl(const code_declt &_code) { clear(DECL); code=_code; } - DEPRECATED("use goto_programt::make_function_call() instead") + DEPRECATED( + SINCE(2019, 2, 13, "use goto_programt::make_function_call() instead")) void make_function_call(const code_function_callt &_code) { clear(FUNCTION_CALL); diff --git a/src/goto-programs/link_to_library.h b/src/goto-programs/link_to_library.h index 4d2222fa5e4..14c43a1b745 100644 --- a/src/goto-programs/link_to_library.h +++ b/src/goto-programs/link_to_library.h @@ -23,7 +23,7 @@ class goto_modelt; class message_handlert; class symbol_tablet; -DEPRECATED("Use link_to_library(goto_model, ...) instead") +DEPRECATED(SINCE(2019, 2, 28, "Use link_to_library(goto_model, ...) instead")) void link_to_library( symbol_tablet &, goto_functionst &, diff --git a/src/goto-symex/ssa_step.h b/src/goto-symex/ssa_step.h index ed67bf937b1..702d62b5417 100644 --- a/src/goto-symex/ssa_step.h +++ b/src/goto-symex/ssa_step.h @@ -191,7 +191,7 @@ class SSA_stept { } - DEPRECATED("Use output without ns param") + DEPRECATED(SINCE(2018, 4, 23, "Use output without ns param")) void output(const namespacet &ns, std::ostream &out) const; void output(std::ostream &out) const; diff --git a/src/solvers/strings/string_constraint_generator.h b/src/solvers/strings/string_constraint_generator.h index a01cc674130..60891c2b730 100644 --- a/src/solvers/strings/string_constraint_generator.h +++ b/src/solvers/strings/string_constraint_generator.h @@ -482,7 +482,7 @@ add_axioms_for_char_literal(const function_application_exprt &f); /// \todo This function is underspecified, we do not compute the exact value /// but over approximate it. /// \deprecated This is Java specific and should be implemented in Java. -DEPRECATED("This is Java specific and should be implemented in Java") +DEPRECATED(SINCE(2017, 10, 5, "Java specific, should be implemented in Java")) std::pair add_axioms_for_code_point_count( symbol_generatort &fresh_symbol, const function_application_exprt &f, @@ -494,6 +494,7 @@ std::pair add_axioms_for_code_point_count( /// argument code points and we approximate this by saying the result is /// between index + offset and index + 2 * offset. /// \deprecated This is Java specific and should be implemented in Java. +DEPRECATED(SINCE(2017, 10, 5, "Java specific, should be implemented in Java")) std::pair add_axioms_for_offset_by_code_point( symbol_generatort &fresh_symbol, const function_application_exprt &f); diff --git a/src/solvers/strings/string_constraint_generator_comparison.cpp b/src/solvers/strings/string_constraint_generator_comparison.cpp index 4b32028894b..0b4ce3b250d 100644 --- a/src/solvers/strings/string_constraint_generator_comparison.cpp +++ b/src/solvers/strings/string_constraint_generator_comparison.cpp @@ -303,7 +303,7 @@ std::pair add_axioms_for_compare_to( /// \deprecated never tested /// \param f: function application with one string argument /// \return a string expression -DEPRECATED("never tested") +DEPRECATED(SINCE(2017, 10, 5, "never tested")) std::pair string_constraint_generatort::add_axioms_for_intern( const function_application_exprt &f) diff --git a/src/solvers/strings/string_constraint_generator_insert.cpp b/src/solvers/strings/string_constraint_generator_insert.cpp index be6e2cb3993..fa06c6d9425 100644 --- a/src/solvers/strings/string_constraint_generator_insert.cpp +++ b/src/solvers/strings/string_constraint_generator_insert.cpp @@ -140,7 +140,7 @@ std::pair add_axioms_for_insert( /// \param array_pool: pool of arrays representing strings /// \param ns: namespace /// \return an expression -DEPRECATED("should convert the value to string and call insert") +DEPRECATED(SINCE(2017, 10, 5, "convert the value to string and call insert")) std::pair add_axioms_for_insert_int( symbol_generatort &fresh_symbol, const function_application_exprt &f, @@ -167,7 +167,7 @@ std::pair add_axioms_for_insert_int( /// integer offset, and a Boolean /// \param array_pool: pool of arrays representing strings /// \return a new string expression -DEPRECATED("should convert the value to string and call insert") +DEPRECATED(SINCE(2017, 10, 5, "convert the value to string and call insert")) std::pair add_axioms_for_insert_bool( symbol_generatort &fresh_symbol, const function_application_exprt &f, @@ -219,7 +219,7 @@ std::pair add_axioms_for_insert_char( /// \param array_pool: pool of arrays representing strings /// \param ns: namespace /// \return a string expression -DEPRECATED("should convert the value to string and call insert") +DEPRECATED(SINCE(2017, 10, 5, "convert the value to string and call insert")) std::pair add_axioms_for_insert_double( symbol_generatort &fresh_symbol, const function_application_exprt &f, @@ -248,7 +248,7 @@ std::pair add_axioms_for_insert_double( /// \param array_pool: pool of arrays representing strings /// \param ns: namespace /// \return a new string expression -DEPRECATED("should convert the value to string and call insert") +DEPRECATED(SINCE(2017, 10, 5, "convert the value to string and call insert")) std::pair add_axioms_for_insert_float( symbol_generatort &fresh_symbol, const function_application_exprt &f, diff --git a/src/solvers/strings/string_constraint_generator_main.cpp b/src/solvers/strings/string_constraint_generator_main.cpp index 05e38461bfb..a7b435221d2 100644 --- a/src/solvers/strings/string_constraint_generator_main.cpp +++ b/src/solvers/strings/string_constraint_generator_main.cpp @@ -487,7 +487,7 @@ string_constraint_generatort::add_axioms_for_function_application( /// or three arguments: string, integer offset and count /// \param array_pool: pool of arrays representing strings /// \return a new string expression -DEPRECATED("should use substring instead") +DEPRECATED(SINCE(2017, 10, 5, "should use substring instead")) std::pair add_axioms_for_copy( symbol_generatort &fresh_symbol, const function_application_exprt &f, diff --git a/src/solvers/strings/string_constraint_generator_testing.cpp b/src/solvers/strings/string_constraint_generator_testing.cpp index 1c24648070c..050bac4b205 100644 --- a/src/solvers/strings/string_constraint_generator_testing.cpp +++ b/src/solvers/strings/string_constraint_generator_testing.cpp @@ -123,7 +123,7 @@ std::pair add_axioms_for_is_prefix( /// \param f: function application with a string argument /// \param array_pool: pool of arrays representing strings /// \return a Boolean expression -DEPRECATED("should use `string_length(s)==0` instead") +DEPRECATED(SINCE(2017, 10, 5, "should use `string_length s == 0` instead")) std::pair add_axioms_for_is_empty( symbol_generatort &fresh_symbol, const function_application_exprt &f, @@ -165,7 +165,8 @@ std::pair add_axioms_for_is_empty( /// argument or the first argument /// \param array_pool: pool of arrays representing strings /// \return Boolean expression `issuffix` -DEPRECATED("should use `strings_startwith(s0, s1, s1.length - s0.length)`") +/// \deprecated Should use `strings_startwith(s0, s1, s1.length - s0.length)`. +DEPRECATED(SINCE(2018, 6, 6, "should use strings_startwith")) std::pair add_axioms_for_is_suffix( symbol_generatort &fresh_symbol, const function_application_exprt &f, diff --git a/src/solvers/strings/string_constraint_generator_valueof.cpp b/src/solvers/strings/string_constraint_generator_valueof.cpp index d10e33fd441..93818f7df2c 100644 --- a/src/solvers/strings/string_constraint_generator_valueof.cpp +++ b/src/solvers/strings/string_constraint_generator_valueof.cpp @@ -42,7 +42,7 @@ static unsigned long to_integer_or_default( /// \param array_pool: pool of arrays representing strings /// \param ns: namespace /// \return a new string expression -DEPRECATED("should use add_axioms_for_string_of_int instead") +DEPRECATED(SINCE(2017, 10, 5, "use add_axioms_for_string_of_int instead")) std::pair add_axioms_from_long( const function_application_exprt &f, array_poolt &array_pool, @@ -63,7 +63,7 @@ std::pair add_axioms_from_long( /// \param f: function application with a Boolean argument /// \param array_pool: pool of arrays representing strings /// \return a new string expression -DEPRECATED("This is Java specific and should be implemented in Java instead") +DEPRECATED(SINCE(2017, 10, 5, "Java specific, should be implemented in Java")) std::pair add_axioms_from_bool( const function_application_exprt &f, array_poolt &array_pool) @@ -80,7 +80,7 @@ std::pair add_axioms_from_bool( /// \param res: string expression for the result /// \param b: Boolean expression /// \return code 0 on success -DEPRECATED("This is Java specific and should be implemented in Java instead") +DEPRECATED(SINCE(2017, 10, 5, "Java specific, should be implemented in Java")) std::pair add_axioms_from_bool(const array_string_exprt &res, const exprt &b) { @@ -212,7 +212,7 @@ static exprt int_of_hex_char(const exprt &chr) /// \param res: string expression for the result /// \param i: an integer argument /// \return code 0 on success -DEPRECATED("use add_axioms_for_string_of_int_with_radix instead") +DEPRECATED(SINCE(2017, 10, 5, "use add_axioms_for_string_of_int_with_radix")) std::pair add_axioms_from_int_hex(const array_string_exprt &res, const exprt &i) { diff --git a/src/util/arith_tools.h b/src/util/arith_tools.h index 606df798fb8..395ab9b5f62 100644 --- a/src/util/arith_tools.h +++ b/src/util/arith_tools.h @@ -27,7 +27,7 @@ class typet; bool to_integer(const constant_exprt &expr, mp_integer &int_value); // returns 'true' on error -DEPRECATED("Use numeric_cast(e) instead") +DEPRECATED(SINCE(2018, 9, 29, "Use numeric_cast(e) instead")) bool to_unsigned_integer(const constant_exprt &expr, unsigned &uint_value); /// Numerical cast provides a unified way of converting from one numerical type diff --git a/src/util/base_type.h b/src/util/base_type.h index ebd8b82dbfc..6e6fe4d2088 100644 --- a/src/util/base_type.h +++ b/src/util/base_type.h @@ -18,13 +18,13 @@ class exprt; class typet; class namespacet; -DEPRECATED("Use == instead") +DEPRECATED(SINCE(2019, 1, 22, "Use == instead")) bool base_type_eq( const typet &type1, const typet &type2, const namespacet &ns); -DEPRECATED("Use == instead") +DEPRECATED(SINCE(2019, 1, 22, "Use == instead")) bool base_type_eq( const exprt &expr1, const exprt &expr2, diff --git a/src/util/byte_operators.h b/src/util/byte_operators.h index a60f61e0b6c..5d5e989e422 100644 --- a/src/util/byte_operators.h +++ b/src/util/byte_operators.h @@ -25,12 +25,14 @@ Author: Daniel Kroening, kroening@kroening.com class byte_extract_exprt:public binary_exprt { public: - DEPRECATED("use byte_extract_exprt(id, op, offset, type) instead") + DEPRECATED( + SINCE(2019, 1, 12, "use byte_extract_exprt(id, op, offset, type) instead")) explicit byte_extract_exprt(irep_idt _id):binary_exprt(_id) { } - DEPRECATED("use byte_extract_exprt(id, op, offset, type) instead") + DEPRECATED( + SINCE(2019, 1, 12, "use byte_extract_exprt(id, op, offset, type) instead")) explicit byte_extract_exprt(irep_idt _id, const typet &_type): binary_exprt(_id, _type) { diff --git a/src/util/deprecate.h b/src/util/deprecate.h index 60f8bb40f2c..71756684a4a 100644 --- a/src/util/deprecate.h +++ b/src/util/deprecate.h @@ -23,4 +23,7 @@ Author: Diffblue Ltd. #define DEPRECATED(msg) #endif +#define SINCE(year, month, day, msg) \ + "deprecated since " #year "-" #month "-" #day "; " msg + #endif // CPROVER_UTIL_DEPRECATE_H diff --git a/src/util/expr.h b/src/util/expr.h index 4877396e99f..078a7dd6fe3 100644 --- a/src/util/expr.h +++ b/src/util/expr.h @@ -121,14 +121,22 @@ class exprt:public irept void reserve_operands(operandst::size_type n) { operands().reserve(n) ; } - DEPRECATED("use add_to_operands(std::move(expr)) instead") + DEPRECATED(SINCE(2018, 10, 1, "use add_to_operands(std::move(expr)) instead")) void move_to_operands(exprt &expr); - DEPRECATED("use add_to_operands(std::move(e1), std::move(e2)) instead") + DEPRECATED(SINCE( + 2018, + 10, + 1, + "use add_to_operands(std::move(e1), std::move(e2)) instead")) void move_to_operands(exprt &e1, exprt &e2); - DEPRECATED( - "use add_to_operands(std::move(e1), std::move(e2), std::move(e3)) instead") + DEPRECATED(SINCE( + 2018, + 10, + 1, + "use add_to_operands(std::move(e1), std::move(e2), std::move(e3))" + "instead")) void move_to_operands(exprt &e1, exprt &e2, exprt &e3); /// Copy the given argument to the end of `exprt`'s operands. @@ -225,7 +233,7 @@ class exprt:public irept op.push_back(std::move(e3)); } - DEPRECATED("use typecast_exprt() instead") + DEPRECATED(SINCE(2019, 1, 19, "use typecast_exprt() instead")) void make_typecast(const typet &_type); void make_bool(bool value); diff --git a/src/util/lispexpr.h b/src/util/lispexpr.h index 8966ba17446..ca23941e7e4 100644 --- a/src/util/lispexpr.h +++ b/src/util/lispexpr.h @@ -6,8 +6,7 @@ Author: Daniel Kroening, kroening@kroening.com \*******************************************************************/ - -// THIS HEADER IS DEPRECATED AND WILL GO AWAY +// THIS HEADER IS DEPRECATED (since 2015-06-30) AND WILL GO AWAY #ifndef CPROVER_UTIL_LISPEXPR_H #define CPROVER_UTIL_LISPEXPR_H diff --git a/src/util/mathematical_expr.h b/src/util/mathematical_expr.h index aa17ab018f0..84647ef85c9 100644 --- a/src/util/mathematical_expr.h +++ b/src/util/mathematical_expr.h @@ -19,7 +19,7 @@ Author: Daniel Kroening, kroening@kroening.com class transt : public ternary_exprt { public: - DEPRECATED("use transt(op0, op1, op2) instead") + DEPRECATED(SINCE(2019, 1, 12, "use transt(op0, op1, op2) instead")) transt() : ternary_exprt(ID_trans) { } @@ -97,7 +97,7 @@ inline transt &to_trans_expr(exprt &expr) class power_exprt : public binary_exprt { public: - DEPRECATED("use power_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use power_exprt(lhs, rhs) instead")) power_exprt() : binary_exprt(ID_power) { } @@ -146,7 +146,7 @@ inline power_exprt &to_power_expr(exprt &expr) class factorial_power_exprt : public binary_exprt { public: - DEPRECATED("use factorial_power_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use factorial_power_exprt(lhs, rhs) instead")) factorial_power_exprt() : binary_exprt(ID_factorial_power) { } @@ -207,7 +207,8 @@ class function_application_exprt : public binary_exprt public: using argumentst = exprt::operandst; - DEPRECATED("use function_application_exprt(fkt, arg) instead") + DEPRECATED( + SINCE(2019, 3, 3, "use function_application_exprt(fkt, arg) instead")) function_application_exprt( const symbol_exprt &_function, const argumentst &_arguments, diff --git a/src/util/message.h b/src/util/message.h index 155ca43fd8d..69eabaed807 100644 --- a/src/util/message.h +++ b/src/util/message.h @@ -183,7 +183,7 @@ class messaget // constructors, destructor - DEPRECATED("use messaget(message_handler) instead") + DEPRECATED(SINCE(2019, 1, 7, "use messaget(message_handler) instead")) messaget(): message_handler(nullptr), mstream(M_DEBUG, *this) diff --git a/src/util/mp_arith.h b/src/util/mp_arith.h index 74e3b8581dd..674a6228d3e 100644 --- a/src/util/mp_arith.h +++ b/src/util/mp_arith.h @@ -50,15 +50,16 @@ const std::string integer2binary(const mp_integer &, std::size_t width); const mp_integer binary2integer(const std::string &, bool is_signed); /// \deprecated use numeric_cast_v instead -DEPRECATED("Use numeric_cast_v instead") +DEPRECATED( + SINCE(2017, 11, 13, "Use numeric_cast_v instead")) mp_integer::ullong_t integer2ulong(const mp_integer &); /// \deprecated use numeric_cast_v instead -DEPRECATED("Use numeric_cast_v instead") +DEPRECATED(SINCE(2017, 11, 13, "Use numeric_cast_v instead")) std::size_t integer2size_t(const mp_integer &); /// \deprecated use numeric_cast_v instead -DEPRECATED("Use numeric_cast_v instead") +DEPRECATED(SINCE(2017, 11, 13, "Use numeric_cast_v instead")) unsigned integer2unsigned(const mp_integer &); #endif // CPROVER_UTIL_MP_ARITH_H diff --git a/src/util/std_code.h b/src/util/std_code.h index 0d4525550a7..8e80cf2f753 100644 --- a/src/util/std_code.h +++ b/src/util/std_code.h @@ -34,7 +34,7 @@ Author: Daniel Kroening, kroening@kroening.com class codet:public exprt { public: - DEPRECATED("use codet(statement) instead") + DEPRECATED(SINCE(2018, 6, 28, "use codet(statement) instead")) codet() : exprt(ID_code, empty_typet()) { } @@ -83,7 +83,7 @@ class codet:public exprt codet &last_statement(); const codet &last_statement() const; - DEPRECATED("use code_blockt(...) instead") + DEPRECATED(SINCE(2019, 2, 6, "use code_blockt(...) instead")) class code_blockt &make_block(); /// Check that the code statement is well-formed (shallow checks only, i.e., @@ -537,7 +537,7 @@ inline code_deadt &to_code_dead(codet &code) class code_assumet:public codet { public: - DEPRECATED("use code_assumet(expr) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_assumet(expr) instead")) code_assumet():codet(ID_assume) { operands().resize(1); @@ -595,7 +595,7 @@ inline code_assumet &to_code_assume(codet &code) class code_assertt:public codet { public: - DEPRECATED("use code_assertt(expr) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_assertt(expr) instead")) code_assertt():codet(ID_assert) { operands().resize(1); @@ -667,7 +667,11 @@ code_blockt create_fatal_assertion( class code_ifthenelset:public codet { public: - DEPRECATED("use code_ifthenelset(condition, then_code[, else_code]) instead") + DEPRECATED(SINCE( + 2018, + 12, + 2, + "use code_ifthenelset(condition, then_code[, else_code]) instead")) code_ifthenelset():codet(ID_ifthenelse) { operands().resize(3); @@ -763,7 +767,7 @@ inline code_ifthenelset &to_code_ifthenelse(codet &code) class code_switcht:public codet { public: - DEPRECATED("use code_switcht(value, body) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_switcht(value, body) instead")) code_switcht():codet(ID_switch) { operands().resize(2); @@ -831,7 +835,7 @@ inline code_switcht &to_code_switch(codet &code) class code_whilet:public codet { public: - DEPRECATED("use code_whilet(cond, body) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_whilet(cond, body) instead")) code_whilet():codet(ID_while) { operands().resize(2); @@ -899,7 +903,7 @@ inline code_whilet &to_code_while(codet &code) class code_dowhilet:public codet { public: - DEPRECATED("use code_dowhilet(cond, body) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_dowhilet(cond, body) instead")) code_dowhilet():codet(ID_dowhile) { operands().resize(2); @@ -967,7 +971,8 @@ inline code_dowhilet &to_code_dowhile(codet &code) class code_fort:public codet { public: - DEPRECATED("use code_fort(init, cond, iter, body) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use code_fort(init, cond, iter, body) instead")) code_fort():codet(ID_for) { operands().resize(4); @@ -1063,7 +1068,7 @@ inline code_fort &to_code_for(codet &code) class code_gotot:public codet { public: - DEPRECATED("use code_gotot(label) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_gotot(label) instead")) code_gotot():codet(ID_goto) { } @@ -1124,7 +1129,7 @@ inline code_gotot &to_code_goto(codet &code) class code_function_callt:public codet { public: - DEPRECATED("Use code_function_callt(...) instead") + DEPRECATED(SINCE(2018, 8, 26, "Use code_function_callt(...) instead")) code_function_callt():codet(ID_function_call) { operands().resize(3); @@ -1324,13 +1329,13 @@ inline code_returnt &to_code_return(codet &code) class code_labelt:public codet { public: - DEPRECATED("use code_labelt(label, _code) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_labelt(label, _code) instead")) code_labelt():codet(ID_label) { operands().resize(1); } - DEPRECATED("use code_labelt(label, _code) instead") + DEPRECATED(SINCE(2019, 2, 6, "use code_labelt(label, _code) instead")) explicit code_labelt(const irep_idt &_label):codet(ID_label) { operands().resize(1); @@ -1401,7 +1406,7 @@ inline code_labelt &to_code_label(codet &code) class code_switch_caset:public codet { public: - DEPRECATED("use code_switch_caset(case_op, code) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_switch_caset(case_op, code) instead")) code_switch_caset():codet(ID_switch_case) { operands().resize(2); @@ -1778,7 +1783,7 @@ inline const code_asm_gcct &to_code_asm_gcc(const codet &code) class code_expressiont:public codet { public: - DEPRECATED("use code_expressiont(expr) instead") + DEPRECATED(SINCE(2018, 6, 28, "use code_expressiont(expr) instead")) code_expressiont():codet(ID_expression) { operands().resize(1); @@ -1840,13 +1845,15 @@ inline const code_expressiont &to_code_expression(const codet &code) class side_effect_exprt : public exprt { public: - DEPRECATED("use side_effect_exprt(statement, type, loc) instead") + DEPRECATED( + SINCE(2018, 6, 28, "use side_effect_exprt(statement, type, loc) instead")) explicit side_effect_exprt(const irep_idt &statement) : exprt(ID_side_effect) { set_statement(statement); } - DEPRECATED("use side_effect_exprt(statement, type, loc) instead") + DEPRECATED( + SINCE(2018, 8, 9, "use side_effect_exprt(statement, type, loc) instead")) side_effect_exprt(const irep_idt &statement, const typet &_type) : exprt(ID_side_effect, _type) { @@ -1924,13 +1931,21 @@ inline const side_effect_exprt &to_side_effect_expr(const exprt &expr) class side_effect_expr_nondett:public side_effect_exprt { public: - DEPRECATED("use side_effect_expr_nondett(statement, type, loc) instead") + DEPRECATED(SINCE( + 2018, + 6, + 28, + "use side_effect_expr_nondett(statement, type, loc) instead")) side_effect_expr_nondett():side_effect_exprt(ID_nondet) { set_nullable(true); } - DEPRECATED("use side_effect_expr_nondett(statement, type, loc) instead") + DEPRECATED(SINCE( + 2018, + 8, + 9, + "use side_effect_expr_nondett(statement, type, loc) instead")) explicit side_effect_expr_nondett(const typet &_type): side_effect_exprt(ID_nondet, _type) { @@ -2052,9 +2067,12 @@ to_side_effect_expr_assign(const exprt &expr) class side_effect_expr_function_callt:public side_effect_exprt { public: - DEPRECATED( + DEPRECATED(SINCE( + 2018, + 6, + 28, "use side_effect_expr_function_callt(" - "function, arguments, type, loc) instead") + "function, arguments, type, loc) instead")) side_effect_expr_function_callt() : side_effect_exprt(ID_function_call, typet(), source_locationt()) { @@ -2062,9 +2080,12 @@ class side_effect_expr_function_callt:public side_effect_exprt op1().id(ID_arguments); } - DEPRECATED( + DEPRECATED(SINCE( + 2018, + 8, + 9, "use side_effect_expr_function_callt(" - "function, arguments, type, loc) instead") + "function, arguments, type, loc) instead")) side_effect_expr_function_callt( const exprt &_function, const exprt::operandst &_arguments) @@ -2076,9 +2097,12 @@ class side_effect_expr_function_callt:public side_effect_exprt arguments() = _arguments; } - DEPRECATED( + DEPRECATED(SINCE( + 2018, + 8, + 9, "use side_effect_expr_function_callt(" - "function, arguments, type, loc) instead") + "function, arguments, type, loc) instead")) side_effect_expr_function_callt( const exprt &_function, const exprt::operandst &_arguments, @@ -2156,7 +2180,8 @@ inline const side_effect_expr_function_callt class side_effect_expr_throwt:public side_effect_exprt { public: - DEPRECATED("use side_effect_expr_throwt(exception_list) instead") + DEPRECATED( + SINCE(2018, 6, 28, "use side_effect_expr_throwt(exception_list) instead")) side_effect_expr_throwt():side_effect_exprt(ID_throw) { } @@ -2390,7 +2415,7 @@ static inline const code_landingpadt &to_code_landingpad(const codet &code) class code_try_catcht:public codet { public: - DEPRECATED("use code_try_catcht(try_code) instead") + DEPRECATED(SINCE(2018, 12, 2, "use code_try_catcht(try_code) instead")) code_try_catcht():codet(ID_try_catch) { operands().resize(1); diff --git a/src/util/std_expr.h b/src/util/std_expr.h index 4a5f918c4ed..e2d1ff13e57 100644 --- a/src/util/std_expr.h +++ b/src/util/std_expr.h @@ -24,7 +24,7 @@ class nullary_exprt : public expr_protectedt { public: // constructors - DEPRECATED("use nullary_exprt(id, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use nullary_exprt(id, type) instead")) explicit nullary_exprt(const irep_idt &_id) : expr_protectedt(_id, typet()) { } @@ -61,13 +61,15 @@ class ternary_exprt : public expr_protectedt { public: // constructors - DEPRECATED("use ternary_exprt(id, op0, op1, op2, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use ternary_exprt(id, op0, op1, op2, type) instead")) explicit ternary_exprt(const irep_idt &_id) : expr_protectedt(_id, type()) { operands().resize(3); } - DEPRECATED("use ternary_exprt(id, op0, op1, op2, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use ternary_exprt(id, op0, op1, op2, type) instead")) explicit ternary_exprt(const irep_idt &_id, const typet &_type) : expr_protectedt(_id, _type) { @@ -100,13 +102,13 @@ class ternary_exprt : public expr_protectedt class symbol_exprt : public nullary_exprt { public: - DEPRECATED("use symbol_exprt(identifier, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use symbol_exprt(identifier, type) instead")) symbol_exprt() : nullary_exprt(ID_symbol) { } /// \param identifier: Name of symbol - DEPRECATED("use symbol_exprt(identifier, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use symbol_exprt(identifier, type) instead")) explicit symbol_exprt(const irep_idt &identifier) : nullary_exprt(ID_symbol) { set_identifier(identifier); @@ -150,20 +152,23 @@ class symbol_exprt : public nullary_exprt class decorated_symbol_exprt:public symbol_exprt { public: - DEPRECATED("use decorated_symbol_exprt(identifier, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use decorated_symbol_exprt(identifier, type) instead")) decorated_symbol_exprt() { } /// \param identifier: Name of symbol - DEPRECATED("use decorated_symbol_exprt(identifier, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use decorated_symbol_exprt(identifier, type) instead")) explicit decorated_symbol_exprt(const irep_idt &identifier): symbol_exprt(identifier) { } /// \param type: Type of symbol - DEPRECATED("use decorated_symbol_exprt(identifier, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use decorated_symbol_exprt(identifier, type) instead")) explicit decorated_symbol_exprt(const typet &type): symbol_exprt(type) { @@ -305,13 +310,13 @@ inline nondet_symbol_exprt &to_nondet_symbol_expr(exprt &expr) class unary_exprt : public expr_protectedt { public: - DEPRECATED("use unary_exprt(id, op) instead") + DEPRECATED(SINCE(2018, 9, 21, "use unary_exprt(id, op) instead")) unary_exprt() : expr_protectedt(irep_idt(), typet()) { operands().resize(1); } - DEPRECATED("use unary_exprt(id, op) instead") + DEPRECATED(SINCE(2018, 9, 21, "use unary_exprt(id, op) instead")) explicit unary_exprt(const irep_idt &_id) : expr_protectedt(_id, typet()) { operands().resize(1); @@ -322,7 +327,7 @@ class unary_exprt : public expr_protectedt { } - DEPRECATED("use unary_exprt(id, op, type) instead") + DEPRECATED(SINCE(2018, 12, 2, "use unary_exprt(id, op, type) instead")) unary_exprt(const irep_idt &_id, const typet &_type) : expr_protectedt(_id, _type) { @@ -389,7 +394,7 @@ inline unary_exprt &to_unary_expr(exprt &expr) class abs_exprt:public unary_exprt { public: - DEPRECATED("use abs_exprt(op) instead") + DEPRECATED(SINCE(2018, 9, 21, "use abs_exprt(op) instead")) abs_exprt() { } @@ -438,7 +443,7 @@ inline abs_exprt &to_abs_expr(exprt &expr) class unary_minus_exprt:public unary_exprt { public: - DEPRECATED("use unary_minus_exprt(op) instead") + DEPRECATED(SINCE(2018, 9, 21, "use unary_minus_exprt(op) instead")) unary_minus_exprt():unary_exprt(ID_unary_minus) { } @@ -600,7 +605,7 @@ inline bswap_exprt &to_bswap_expr(exprt &expr) class predicate_exprt : public expr_protectedt { public: - DEPRECATED("use predicate_exprt(id) instead") + DEPRECATED(SINCE(2018, 12, 2, "use predicate_exprt(id) instead")) predicate_exprt() : expr_protectedt(irep_idt(), bool_typet()) { } @@ -610,14 +615,15 @@ class predicate_exprt : public expr_protectedt { } - DEPRECATED("use unary_predicate_exprt(id, op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use unary_predicate_exprt(id, op) instead")) predicate_exprt(const irep_idt &_id, const exprt &_op) : expr_protectedt(_id, bool_typet()) { add_to_operands(_op); } - DEPRECATED("use binary_predicate_exprt(op1, id, op2) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use binary_predicate_exprt(op1, id, op2) instead")) predicate_exprt(const irep_idt &_id, const exprt &_op0, const exprt &_op1) : expr_protectedt(_id, bool_typet()) { @@ -630,12 +636,12 @@ class predicate_exprt : public expr_protectedt class unary_predicate_exprt:public unary_exprt { public: - DEPRECATED("use unary_predicate_exprt(id, op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use unary_predicate_exprt(id, op) instead")) unary_predicate_exprt():unary_exprt(irep_idt(), bool_typet()) { } - DEPRECATED("use unary_predicate_exprt(id, op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use unary_predicate_exprt(id, op) instead")) explicit unary_predicate_exprt(const irep_idt &_id): unary_exprt(_id, bool_typet()) { @@ -652,7 +658,7 @@ class unary_predicate_exprt:public unary_exprt class sign_exprt:public unary_predicate_exprt { public: - DEPRECATED("use sign_exprt(op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use sign_exprt(op) instead")) sign_exprt() { } @@ -701,19 +707,19 @@ inline sign_exprt &to_sign_expr(exprt &expr) class binary_exprt : public expr_protectedt { public: - DEPRECATED("use binary_exprt(lhs, id, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use binary_exprt(lhs, id, rhs) instead")) binary_exprt() : expr_protectedt(irep_idt(), typet()) { operands().resize(2); } - DEPRECATED("use binary_exprt(lhs, id, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use binary_exprt(lhs, id, rhs) instead")) explicit binary_exprt(const irep_idt &_id) : expr_protectedt(_id, typet()) { operands().resize(2); } - DEPRECATED("use binary_exprt(lhs, id, rhs, type) instead") + DEPRECATED(SINCE(2018, 12, 2, "use binary_exprt(lhs, id, rhs, type) instead")) binary_exprt(const irep_idt &_id, const typet &_type) : expr_protectedt(_id, _type) { @@ -793,12 +799,14 @@ inline binary_exprt &to_binary_expr(exprt &expr) class binary_predicate_exprt:public binary_exprt { public: - DEPRECATED("use binary_predicate_exprt(lhs, id, rhs) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use binary_predicate_exprt(lhs, id, rhs) instead")) binary_predicate_exprt():binary_exprt(irep_idt(), bool_typet()) { } - DEPRECATED("use binary_predicate_exprt(lhs, id, rhs) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use binary_predicate_exprt(lhs, id, rhs) instead")) explicit binary_predicate_exprt(const irep_idt &_id): binary_exprt(_id, bool_typet()) { @@ -834,12 +842,14 @@ class binary_predicate_exprt:public binary_exprt class binary_relation_exprt:public binary_predicate_exprt { public: - DEPRECATED("use binary_relation_exprt(lhs, id, rhs) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use binary_relation_exprt(lhs, id, rhs) instead")) binary_relation_exprt() { } - DEPRECATED("use binary_relation_exprt(lhs, id, rhs) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use binary_relation_exprt(lhs, id, rhs) instead")) explicit binary_relation_exprt(const irep_idt &id): binary_predicate_exprt(id) { @@ -928,17 +938,17 @@ inline binary_relation_exprt &to_binary_relation_expr(exprt &expr) class multi_ary_exprt : public expr_protectedt { public: - DEPRECATED("use multi_ary_exprt(id, op, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use multi_ary_exprt(id, op, type) instead")) multi_ary_exprt() : expr_protectedt(irep_idt(), typet()) { } - DEPRECATED("use multi_ary_exprt(id, op, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use multi_ary_exprt(id, op, type) instead")) explicit multi_ary_exprt(const irep_idt &_id) : expr_protectedt(_id, typet()) { } - DEPRECATED("use multi_ary_exprt(id, op, type) instead") + DEPRECATED(SINCE(2018, 12, 7, "use multi_ary_exprt(id, op, type) instead")) multi_ary_exprt(const irep_idt &_id, const typet &_type) : expr_protectedt(_id, _type) { @@ -1034,12 +1044,12 @@ inline multi_ary_exprt &to_multi_ary_expr(exprt &expr) class plus_exprt:public multi_ary_exprt { public: - DEPRECATED("use plus_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use plus_exprt(lhs, rhs) instead")) plus_exprt():multi_ary_exprt(ID_plus) { } - DEPRECATED("use plus_exprt(lhs, rhs, type) instead") + DEPRECATED(SINCE(2019, 1, 12, "use plus_exprt(lhs, rhs, type) instead")) plus_exprt(const typet &type) : multi_ary_exprt(ID_plus, type) { } @@ -1103,7 +1113,7 @@ inline plus_exprt &to_plus_expr(exprt &expr) class minus_exprt:public binary_exprt { public: - DEPRECATED("use minus_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use minus_exprt(lhs, rhs) instead")) minus_exprt():binary_exprt(ID_minus) { } @@ -1154,7 +1164,7 @@ inline minus_exprt &to_minus_expr(exprt &expr) class mult_exprt:public multi_ary_exprt { public: - DEPRECATED("use mult_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use mult_exprt(lhs, rhs) instead")) mult_exprt():multi_ary_exprt(ID_mult) { } @@ -1204,7 +1214,7 @@ inline mult_exprt &to_mult_expr(exprt &expr) class div_exprt:public binary_exprt { public: - DEPRECATED("use div_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use div_exprt(lhs, rhs) instead")) div_exprt():binary_exprt(ID_div) { } @@ -1278,7 +1288,7 @@ inline div_exprt &to_div_expr(exprt &expr) class mod_exprt:public binary_exprt { public: - DEPRECATED("use mod_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use mod_exprt(lhs, rhs) instead")) mod_exprt():binary_exprt(ID_mod) { } @@ -1328,7 +1338,7 @@ inline mod_exprt &to_mod_expr(exprt &expr) class rem_exprt:public binary_exprt { public: - DEPRECATED("use rem_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use rem_exprt(lhs, rhs) instead")) rem_exprt():binary_exprt(ID_rem) { } @@ -1378,7 +1388,7 @@ inline rem_exprt &to_rem_expr(exprt &expr) class equal_exprt:public binary_relation_exprt { public: - DEPRECATED("use equal_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use equal_exprt(lhs, rhs) instead")) equal_exprt():binary_relation_exprt(ID_equal) { } @@ -1441,7 +1451,7 @@ inline equal_exprt &to_equal_expr(exprt &expr) class notequal_exprt:public binary_relation_exprt { public: - DEPRECATED("use notequal_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 9, 21, "use notequal_exprt(lhs, rhs) instead")) notequal_exprt():binary_relation_exprt(ID_notequal) { } @@ -1491,12 +1501,12 @@ inline notequal_exprt &to_notequal_expr(exprt &expr) class index_exprt:public binary_exprt { public: - DEPRECATED("use index_exprt(array, index) instead") + DEPRECATED(SINCE(2018, 9, 21, "use index_exprt(array, index) instead")) index_exprt():binary_exprt(ID_index) { } - DEPRECATED("use index_exprt(array, index) instead") + DEPRECATED(SINCE(2018, 9, 21, "use index_exprt(array, index) instead")) explicit index_exprt(const typet &_type):binary_exprt(ID_index, _type) { } @@ -1575,7 +1585,7 @@ inline index_exprt &to_index_expr(exprt &expr) class array_of_exprt:public unary_exprt { public: - DEPRECATED("use array_of_exprt(what, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use array_of_exprt(what, type) instead")) array_of_exprt():unary_exprt(ID_array_of) { } @@ -1635,7 +1645,7 @@ inline array_of_exprt &to_array_of_expr(exprt &expr) class array_exprt : public multi_ary_exprt { public: - DEPRECATED("use array_exprt(operands, type) instead") + DEPRECATED(SINCE(2019, 1, 12, "use array_exprt(operands, type) instead")) explicit array_exprt(const array_typet &_type) : multi_ary_exprt(ID_array, _type) { @@ -1687,7 +1697,7 @@ inline array_exprt &to_array_expr(exprt &expr) class array_list_exprt : public multi_ary_exprt { public: - DEPRECATED("use array_list_exprt(operands, type) instead") + DEPRECATED(SINCE(2019, 1, 12, "use array_list_exprt(operands, type) instead")) explicit array_list_exprt(const array_typet &_type) : multi_ary_exprt(ID_array_list, _type) { @@ -1746,12 +1756,12 @@ inline array_list_exprt &to_array_list_expr(exprt &expr) class vector_exprt : public multi_ary_exprt { public: - DEPRECATED("use vector_exprt(type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use vector_exprt(type) instead")) vector_exprt() : multi_ary_exprt(ID_vector) { } - DEPRECATED("use vector_exprt(operands, type) instead") + DEPRECATED(SINCE(2019, 1, 12, "use vector_exprt(operands, type) instead")) explicit vector_exprt(const vector_typet &_type) : multi_ary_exprt(ID_vector, _type) { @@ -1793,12 +1803,14 @@ inline vector_exprt &to_vector_expr(exprt &expr) class union_exprt:public unary_exprt { public: - DEPRECATED("use union_exprt(component_name, value, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use union_exprt(component_name, value, type) instead")) union_exprt():unary_exprt(ID_union) { } - DEPRECATED("use union_exprt(component_name, value, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use union_exprt(component_name, value, type) instead")) explicit union_exprt(const typet &_type): unary_exprt(ID_union, _type) { @@ -1870,12 +1882,14 @@ inline union_exprt &to_union_expr(exprt &expr) class struct_exprt : public multi_ary_exprt { public: - DEPRECATED("use struct_exprt(component_name, value, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use struct_exprt(component_name, value, type) instead")) struct_exprt() : multi_ary_exprt(ID_struct) { } - DEPRECATED("use struct_exprt(component_name, value, type) instead") + DEPRECATED( + SINCE(2019, 1, 12, "use struct_exprt(component_name, value, type) instead")) explicit struct_exprt(const typet &_type) : multi_ary_exprt(ID_struct, _type) { } @@ -1919,12 +1933,12 @@ inline struct_exprt &to_struct_expr(exprt &expr) class complex_exprt:public binary_exprt { public: - DEPRECATED("use complex_exprt(r, i, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use complex_exprt(r, i, type) instead")) complex_exprt():binary_exprt(ID_complex) { } - DEPRECATED("use complex_exprt(r, i, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use complex_exprt(r, i, type) instead")) explicit complex_exprt(const complex_typet &_type): binary_exprt(ID_complex, _type) { @@ -2178,7 +2192,7 @@ inline object_descriptor_exprt &to_object_descriptor_expr(exprt &expr) class dynamic_object_exprt:public binary_exprt { public: - DEPRECATED("use dynamic_object_exprt(type) instead") + DEPRECATED(SINCE(2019, 2, 11, "use dynamic_object_exprt(type) instead")) dynamic_object_exprt() : binary_exprt(exprt(ID_unknown), ID_dynamic_object, exprt(ID_unknown)) { @@ -2249,7 +2263,7 @@ inline dynamic_object_exprt &to_dynamic_object_expr(exprt &expr) class typecast_exprt:public unary_exprt { public: - DEPRECATED("use typecast_exprt(op, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use typecast_exprt(op, type) instead")) explicit typecast_exprt(const typet &_type):unary_exprt(ID_typecast, _type) { } @@ -2308,7 +2322,8 @@ inline typecast_exprt &to_typecast_expr(exprt &expr) class floatbv_typecast_exprt:public binary_exprt { public: - DEPRECATED("use floatbv_typecast_exprt(op, r, type) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use floatbv_typecast_exprt(op, r, type) instead")) floatbv_typecast_exprt():binary_exprt(ID_floatbv_typecast) { } @@ -2383,7 +2398,7 @@ inline floatbv_typecast_exprt &to_floatbv_typecast_expr(exprt &expr) class and_exprt:public multi_ary_exprt { public: - DEPRECATED("use and_exprt(op, op) instead") + DEPRECATED(SINCE(2019, 1, 12, "use and_exprt(op, op) instead")) and_exprt():multi_ary_exprt(ID_and, bool_typet()) { } @@ -2451,7 +2466,7 @@ inline and_exprt &to_and_expr(exprt &expr) class implies_exprt:public binary_exprt { public: - DEPRECATED("use implies_exprt(a, b) instead") + DEPRECATED(SINCE(2018, 9, 21, "use implies_exprt(a, b) instead")) implies_exprt():binary_exprt(ID_implies, bool_typet()) { } @@ -2501,7 +2516,7 @@ inline implies_exprt &to_implies_expr(exprt &expr) class or_exprt:public multi_ary_exprt { public: - DEPRECATED("use or_exprt(op, op) instead") + DEPRECATED(SINCE(2019, 1, 12, "use or_exprt(op, op) instead")) or_exprt():multi_ary_exprt(ID_or, bool_typet()) { } @@ -2569,7 +2584,7 @@ inline or_exprt &to_or_expr(exprt &expr) class xor_exprt:public multi_ary_exprt { public: - DEPRECATED("use xor_exprt(op, op) instead") + DEPRECATED(SINCE(2019, 1, 12, "use xor_exprt(op, op) instead")) xor_exprt():multi_ary_exprt(ID_bitxor, bool_typet()) { } @@ -2610,7 +2625,7 @@ inline xor_exprt &to_xor_expr(exprt &expr) class bitnot_exprt:public unary_exprt { public: - DEPRECATED("use bitnot_exprt(op) instead") + DEPRECATED(SINCE(2018, 9, 21, "use bitnot_exprt(op) instead")) bitnot_exprt():unary_exprt(ID_bitnot) { } @@ -2659,7 +2674,7 @@ inline bitnot_exprt &to_bitnot_expr(exprt &expr) class bitor_exprt:public multi_ary_exprt { public: - DEPRECATED("use bitor_exprt(op0, op1) instead") + DEPRECATED(SINCE(2018, 9, 21, "use bitor_exprt(op0, op1) instead")) bitor_exprt():multi_ary_exprt(ID_bitor) { } @@ -2700,7 +2715,7 @@ inline bitor_exprt &to_bitor_expr(exprt &expr) class bitxor_exprt:public multi_ary_exprt { public: - DEPRECATED("use bitxor_exprt(op0, op1) instead") + DEPRECATED(SINCE(2018, 9, 21, "use bitxor_exprt(op0, op1) instead")) bitxor_exprt():multi_ary_exprt(ID_bitxor) { } @@ -2741,7 +2756,7 @@ inline bitxor_exprt &to_bitxor_expr(exprt &expr) class bitand_exprt:public multi_ary_exprt { public: - DEPRECATED("use bitand_exprt(op0, op1) instead") + DEPRECATED(SINCE(2018, 9, 21, "use bitand_exprt(op0, op1) instead")) bitand_exprt():multi_ary_exprt(ID_bitand) { } @@ -2782,12 +2797,12 @@ inline bitand_exprt &to_bitand_expr(exprt &expr) class shift_exprt:public binary_exprt { public: - DEPRECATED("use shift_exprt(value, id, distance) instead") + DEPRECATED(SINCE(2018, 9, 21, "use shift_exprt(value, id, distance) instead")) explicit shift_exprt(const irep_idt &_id):binary_exprt(_id) { } - DEPRECATED("use shift_exprt(value, id, distance) instead") + DEPRECATED(SINCE(2018, 9, 21, "use shift_exprt(value, id, distance) instead")) shift_exprt(const irep_idt &_id, const typet &_type): binary_exprt(_id, _type) { @@ -2858,7 +2873,7 @@ inline shift_exprt &to_shift_expr(exprt &expr) class shl_exprt:public shift_exprt { public: - DEPRECATED("use shl_exprt(value, distance) instead") + DEPRECATED(SINCE(2018, 9, 21, "use shl_exprt(value, distance) instead")) shl_exprt():shift_exprt(ID_shl) { } @@ -2901,7 +2916,7 @@ inline shl_exprt &to_shl_expr(exprt &expr) class ashr_exprt:public shift_exprt { public: - DEPRECATED("use ashl_exprt(value, distance) instead") + DEPRECATED(SINCE(2018, 9, 21, "use ashl_exprt(value, distance) instead")) ashr_exprt():shift_exprt(ID_ashr) { } @@ -2921,7 +2936,7 @@ class ashr_exprt:public shift_exprt class lshr_exprt:public shift_exprt { public: - DEPRECATED("use lshl_exprt(value, distance) instead") + DEPRECATED(SINCE(2018, 9, 21, "use lshl_exprt(value, distance) instead")) lshr_exprt():shift_exprt(ID_lshr) { } @@ -2941,7 +2956,7 @@ class lshr_exprt:public shift_exprt class extractbit_exprt:public binary_predicate_exprt { public: - DEPRECATED("use extractbit_exprt(value, index) instead") + DEPRECATED(SINCE(2018, 9, 21, "use extractbit_exprt(value, index) instead")) extractbit_exprt():binary_predicate_exprt(ID_extractbit) { } @@ -3014,7 +3029,8 @@ inline extractbit_exprt &to_extractbit_expr(exprt &expr) class extractbits_exprt : public expr_protectedt { public: - DEPRECATED("use extractbits_exprt(value, upper, lower) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use extractbits_exprt(value, upper, lower) instead")) extractbits_exprt() : expr_protectedt(ID_extractbits, typet()) { operands().resize(3); @@ -3171,7 +3187,7 @@ class not_exprt:public unary_exprt PRECONDITION(as_const(*this).op().type().id() == ID_bool); } - DEPRECATED("use not_exprt(op) instead") + DEPRECATED(SINCE(2019, 1, 12, "use not_exprt(op) instead")) not_exprt():unary_exprt(ID_not, bool_typet()) { } @@ -3216,12 +3232,12 @@ inline not_exprt &to_not_expr(exprt &expr) class dereference_exprt:public unary_exprt { public: - DEPRECATED("use dereference_exprt(pointer) instead") + DEPRECATED(SINCE(2018, 9, 21, "use dereference_exprt(pointer) instead")) dereference_exprt():unary_exprt(ID_dereference) { } - DEPRECATED("use dereference_exprt(pointer) instead") + DEPRECATED(SINCE(2018, 9, 21, "use dereference_exprt(pointer) instead")) explicit dereference_exprt(const typet &type): unary_exprt(ID_dereference, type) { @@ -3318,7 +3334,7 @@ class if_exprt : public ternary_exprt { } - DEPRECATED("use if_exprt(cond, t, f) instead") + DEPRECATED(SINCE(2018, 9, 21, "use if_exprt(cond, t, f) instead")) if_exprt() : ternary_exprt(ID_if) { } @@ -3402,7 +3418,8 @@ class with_exprt : public expr_protectedt { } - DEPRECATED("use with_exprt(old, where, new_value) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use with_exprt(old, where, new_value) instead")) with_exprt() : expr_protectedt(ID_with, typet()) { operands().resize(3); @@ -3594,12 +3611,14 @@ class update_exprt : public ternary_exprt { } - DEPRECATED("use update_exprt(old, where, new_value) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use update_exprt(old, where, new_value) instead")) explicit update_exprt(const typet &_type) : ternary_exprt(ID_update, _type) { } - DEPRECATED("use update_exprt(old, where, new_value) instead") + DEPRECATED( + SINCE(2018, 9, 21, "use update_exprt(old, where, new_value) instead")) update_exprt() : ternary_exprt(ID_update) { op1().id(ID_designator); @@ -3778,7 +3797,7 @@ class member_exprt:public unary_exprt set_component_name(c.get_name()); } - DEPRECATED("use member_exprt(op, c) instead") + DEPRECATED(SINCE(2018, 9, 21, "use member_exprt(op, c) instead")) member_exprt():unary_exprt(ID_member) { } @@ -3880,7 +3899,7 @@ class isnan_exprt:public unary_predicate_exprt { } - DEPRECATED("use isnan_exprt(op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use isnan_exprt(op) instead")) isnan_exprt():unary_predicate_exprt(ID_isnan) { } @@ -3930,7 +3949,7 @@ class isinf_exprt:public unary_predicate_exprt { } - DEPRECATED("use isinf_exprt(op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use isinf_exprt(op) instead")) isinf_exprt():unary_predicate_exprt(ID_isinf) { } @@ -3980,7 +3999,7 @@ class isfinite_exprt:public unary_predicate_exprt { } - DEPRECATED("use isfinite_exprt(op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use isfinite_exprt(op) instead")) isfinite_exprt():unary_predicate_exprt(ID_isfinite) { } @@ -4030,7 +4049,7 @@ class isnormal_exprt:public unary_predicate_exprt { } - DEPRECATED("use isnormal_exprt(op) instead") + DEPRECATED(SINCE(2018, 12, 2, "use isnormal_exprt(op) instead")) isnormal_exprt():unary_predicate_exprt(ID_isnormal) { } @@ -4075,7 +4094,7 @@ inline isnormal_exprt &to_isnormal_expr(exprt &expr) class ieee_float_equal_exprt:public binary_relation_exprt { public: - DEPRECATED("use ieee_float_equal_exprt(lhs, rhs) instead") + DEPRECATED(SINCE(2018, 12, 2, "use ieee_float_equal_exprt(lhs, rhs) instead")) ieee_float_equal_exprt():binary_relation_exprt(ID_ieee_float_equal) { } @@ -4129,7 +4148,8 @@ inline ieee_float_equal_exprt &to_ieee_float_equal_expr(exprt &expr) class ieee_float_notequal_exprt:public binary_relation_exprt { public: - DEPRECATED("use ieee_float_notequal_exprt(lhs, rhs) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use ieee_float_notequal_exprt(lhs, rhs) instead")) ieee_float_notequal_exprt(): binary_relation_exprt(ID_ieee_float_notequal) { @@ -4267,7 +4287,7 @@ inline ieee_float_op_exprt &to_ieee_float_op_expr(exprt &expr) class type_exprt : public nullary_exprt { public: - DEPRECATED("use type_exprt(type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use type_exprt(type) instead")) type_exprt() : nullary_exprt(ID_type) { } @@ -4281,12 +4301,12 @@ class type_exprt : public nullary_exprt class constant_exprt : public expr_protectedt { public: - DEPRECATED("use constant_exprt(value, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use constant_exprt(value, type) instead")) constant_exprt() : expr_protectedt(ID_constant, typet()) { } - DEPRECATED("use constant_exprt(value, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use constant_exprt(value, type) instead")) explicit constant_exprt(const typet &type) : expr_protectedt(ID_constant, type) { @@ -4379,12 +4399,12 @@ class null_pointer_exprt:public constant_exprt class replication_exprt : public binary_exprt { public: - DEPRECATED("use replication_exprt(times, value) instead") + DEPRECATED(SINCE(2018, 9, 21, "use replication_exprt(times, value) instead")) replication_exprt() : binary_exprt(ID_replication) { } - DEPRECATED("use replication_exprt(times, value) instead") + DEPRECATED(SINCE(2018, 9, 21, "use replication_exprt(times, value) instead")) explicit replication_exprt(const typet &_type) : binary_exprt(ID_replication, _type) { @@ -4458,12 +4478,12 @@ inline replication_exprt &to_replication_expr(exprt &expr) class concatenation_exprt : public multi_ary_exprt { public: - DEPRECATED("use concatenation_exprt(op, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use concatenation_exprt(op, type) instead")) concatenation_exprt() : multi_ary_exprt(ID_concatenation) { } - DEPRECATED("use concatenation_exprt(op, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use concatenation_exprt(op, type) instead")) explicit concatenation_exprt(const typet &_type) : multi_ary_exprt(ID_concatenation, _type) { @@ -4602,7 +4622,7 @@ inline let_exprt &to_let_expr(exprt &expr) class popcount_exprt: public unary_exprt { public: - DEPRECATED("use popcount_exprt(op, type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use popcount_exprt(op, type) instead")) popcount_exprt(): unary_exprt(ID_popcount) { } @@ -4658,7 +4678,7 @@ inline popcount_exprt &to_popcount_expr(exprt &expr) class cond_exprt : public multi_ary_exprt { public: - DEPRECATED("use cond_exprt(operands, type) instead") + DEPRECATED(SINCE(2019, 1, 12, "use cond_exprt(operands, type) instead")) explicit cond_exprt(const typet &_type) : multi_ary_exprt(ID_cond, _type) { } diff --git a/src/util/std_types.h b/src/util/std_types.h index a0b7e33a76a..a6d9c21271b 100644 --- a/src/util/std_types.h +++ b/src/util/std_types.h @@ -37,7 +37,8 @@ class bool_typet:public typet /// The NIL type, i.e., an invalid type, no value. /// \deprecated Use `optional` instead. // NOLINTNEXTLINE -class DEPRECATED("Use `optional` instead.") nil_typet : public typet +class DEPRECATED(SINCE(2018, 8, 22, "Use `optional` instead.")) nil_typet + : public typet { public: nil_typet():typet(static_cast(get_nil_irep())) @@ -749,7 +750,7 @@ class code_typet:public typet } /// \deprecated - DEPRECATED("Use the two argument constructor instead") + DEPRECATED(SINCE(2018, 6, 4, "Use the two argument constructor instead")) code_typet():typet(ID_code) { // make sure these properties are always there to avoid problems @@ -763,7 +764,7 @@ class code_typet:public typet class parametert:public exprt { public: - DEPRECATED("use parametert(type) instead") + DEPRECATED(SINCE(2018, 9, 21, "use parametert(type) instead")) parametert():exprt(ID_parameter) { } @@ -1781,7 +1782,7 @@ inline vector_typet &to_vector_type(typet &type) class complex_typet:public type_with_subtypet { public: - DEPRECATED("use complex_typet(type) instead") + DEPRECATED(SINCE(2018, 12, 2, "use complex_typet(type) instead")) complex_typet():type_with_subtypet(ID_complex) { } diff --git a/src/util/string_expr.h b/src/util/string_expr.h index ea65685fa8e..05126976104 100644 --- a/src/util/string_expr.h +++ b/src/util/string_expr.h @@ -114,7 +114,11 @@ inline const array_string_exprt &to_array_string_expr(const exprt &expr) class refined_string_exprt : public struct_exprt { public: - DEPRECATED("use refined_string_exprt(length, content, type) instead") + DEPRECATED(SINCE( + 2019, + 1, + 12, + "use refined_string_exprt(length, content, type) instead")) refined_string_exprt() : struct_exprt() { } diff --git a/src/util/type.h b/src/util/type.h index d89904be086..4589fbe8eef 100644 --- a/src/util/type.h +++ b/src/util/type.h @@ -138,7 +138,7 @@ class typet:public irept class type_with_subtypet:public typet { public: - DEPRECATED("use type_with_subtypet(id, subtype) instead") + DEPRECATED(SINCE(2018, 12, 2, "use type_with_subtypet(id, subtype) instead")) explicit type_with_subtypet(const irep_idt &_id):typet(_id) { } type_with_subtypet(irep_idt _id, typet _subtype) @@ -173,10 +173,12 @@ class type_with_subtypest:public typet public: typedef std::vector subtypest; - DEPRECATED("use type_with_subtypest(id, subtypes) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use type_with_subtypest(id, subtypes) instead")) type_with_subtypest() { } - DEPRECATED("use type_with_subtypest(id, subtypes) instead") + DEPRECATED( + SINCE(2018, 12, 2, "use type_with_subtypest(id, subtypes) instead")) explicit type_with_subtypest(const irep_idt &_id):typet(_id) { } type_with_subtypest(const irep_idt &_id, const subtypest &_subtypes)