From 91f242d37dd87d601a8c1fe2dc35c6482a842659 Mon Sep 17 00:00:00 2001
From: Andrey Saranchin <Andrey22102001@gmail.com>
Date: Wed, 10 Jan 2024 14:22:55 +0300
Subject: [PATCH 1/4] decoder: drop old decoder

The old decoder is no longer suuported - let's remove it. There is 0.1.0
version of tntcxx for ones who want to use it.
---
 src/mpp/Dec.hpp     | 950 --------------------------------------------
 test/EncDecTest.cpp | 355 -----------------
 2 files changed, 1305 deletions(-)

diff --git a/src/mpp/Dec.hpp b/src/mpp/Dec.hpp
index 79bc00d8e..40cfb09b6 100644
--- a/src/mpp/Dec.hpp
+++ b/src/mpp/Dec.hpp
@@ -1268,953 +1268,3 @@ decode(BUF& buf, T&&... t)
 }
 
 } // namespace mpp
-
-#include "../Utils/ObjHolder.hpp"
-
-namespace mpp {
-
-struct DefaultErrorHandler {
-	void BadMsgpack() {}
-	void WrongType(Family /*expected*/, Family /*got*/) {}
-	void MaxDepthReached() {}
-};
-
-template <class BUFFER>
-struct ReaderTemplate : DefaultErrorHandler {
-	static constexpr Family VALID_TYPES = MP_ANY;
-	template <class T>
-	void Value(const typename BUFFER::iterator&, compact::Family, T&&) {}
-	typename BUFFER::iterator* StoreEndIterator() { return nullptr; }
-};
-
-template <class BUFFER, Family TYPE>
-struct SimpleReaderBase : DefaultErrorHandler {
-	using BufferIterator_t = typename BUFFER::iterator;
-	static constexpr Family VALID_TYPES = TYPE;
-	BufferIterator_t* StoreEndIterator() { return nullptr; }
-};
-
-template <class BUFFER, Family TYPE, class T>
-struct SimpleReader : SimpleReaderBase<BUFFER, TYPE> {
-	using BufferIterator_t = typename BUFFER::iterator;
-	explicit SimpleReader(T& t) : value(t) {}
-	template <class U>
-	void Value(const BufferIterator_t&, compact::Family, U&& u)
-	{
-		// A check may be required here.
-		value = u;
-	}
-	T& value;
-};
-
-template <class BUFFER, size_t MAX_SIZE>
-struct SimpleStrReader : SimpleReaderBase<BUFFER, MP_STR> {
-	using BufferIterator_t = typename BUFFER::iterator;
-	SimpleStrReader(char *dst, size_t &size) : m_Dst(dst), m_Size(size) {}
-	void Value(BufferIterator_t& itr, compact::Family, const StrValue& v)
-	{
-		m_Size = v.size;
-		size_t read_size = std::min(MAX_SIZE, m_Size);
-		BufferIterator_t walker = itr;
-		walker += v.offset;
-		for (size_t i = 0; i < read_size; i++) {
-			m_Dst[i] = *walker;
-			++walker;
-		}
-	}
-	char *m_Dst;
-	size_t& m_Size;
-};
-
-template <class BUFFER, size_t MAX_SIZE, Family TYPE, class T>
-struct SimpleArrDataReader : SimpleReaderBase<BUFFER, TYPE> {
-	using BufferIterator_t = typename BUFFER::iterator;
-	explicit SimpleArrDataReader(T *dst) : m_Dst(dst) {}
-	template <class U>
-	void Value(const BufferIterator_t&, compact::Family, U&& u)
-	{
-		if (m_I >= MAX_SIZE)
-			return;
-		m_Dst[m_I++] = u;
-	}
-	T *m_Dst;
-	size_t m_I = 0;
-};
-
-template <class DEC, class BUFFER, size_t MAX_SIZE, Family TYPE, class T>
-struct SimpleArrReader : SimpleReaderBase<BUFFER, MP_ARR> {
-	using BufferIterator_t = typename BUFFER::iterator;
-	SimpleArrReader(DEC& dec, T *dst, size_t &size)
-		: m_Dec(dec), m_Dst(dst), m_Size(size) {}
-	void Value(const BufferIterator_t&, compact::Family, ArrValue v)
-	{
-		m_Size = std::min(MAX_SIZE, (size_t)v.size);
-		using Reader_t = SimpleArrDataReader<BUFFER, MAX_SIZE, TYPE, T>;
-		m_Dec.SetReader(false, Reader_t{m_Dst});
-	}
-
-	DEC& m_Dec;
-	T *m_Dst;
-	size_t& m_Size;
-};
-
-template <class BUFFER>
-class Dec
-{
-public:
-	using Dec_t = Dec<BUFFER>;
-	using Buffer_t = BUFFER;
-	using BufferIterator_t = typename BUFFER::iterator;
-
-	static constexpr size_t MAX_DEPTH = 16;
-	static constexpr size_t MAX_READER_SIZE = 32;
-
-	using Transition_t = void(Dec_t::*)();
-	struct State {
-		const Transition_t *transitions;
-		BufferIterator_t *storeEndIterator;
-		tnt::ObjHolder<MAX_READER_SIZE> objHolder;
-	};
-
-private:
-	struct Level {
-		State state[2];
-		size_t countdown;
-		size_t stateMask;
-	};
-	Level m_Levels[MAX_DEPTH];
-	Level *m_CurLevel = m_Levels;
-
-	template<class READER, class... ARGS>
-	void FillState(State &st, ARGS&&... args);
-	void FillSkipState(State &st, BufferIterator_t *save_end = nullptr);
-
-public:
-	explicit Dec(Buffer_t &buf)
-		: m_Buf(buf), m_Cur(m_Buf.begin())
-	{
-		for (auto& l : m_Levels)
-			l.countdown = l.stateMask = 0;
-	}
-
-	template <class T, class... U>
-	void SetReader(bool second, U&&... u);
-	template <class T>
-	void SetReader(bool second, T&& t);
-	void Skip(BufferIterator_t *saveEnd = nullptr);
-	void SetPosition(BufferIterator_t &itr);
-	BufferIterator_t getPosition() { return m_Cur; }
-
-	inline ReadResult_t Read();
-
-	inline void AbortAndSkipRead(ReadResult_t error = READ_ABORTED_BY_USER);
-	inline void AbandonDecoder(ReadResult_t error = READ_ABORTED_BY_USER);
-
-	State& CurState() { return m_CurLevel->state[m_CurLevel->countdown & m_CurLevel->stateMask]; }
-	State& LastState() { return m_CurLevel->state[(1 ^ m_CurLevel->countdown) & m_CurLevel->stateMask]; }
-	State& FirstState() { return m_CurLevel->state[0]; }
-	State& SecondState() { return m_CurLevel->state[1]; }
-
-	template <class DEC, class READER, class SEQUENCE>
-	friend struct ReaderMap;
-
-private:
-	template <class READER>
-	void ReadNil();
-	template <class READER>
-	void ReadBad();
-	template <class READER>
-	void ReadBool();
-	template <class READER, class T>
-	void ReadUint();
-	template <class READER, class T>
-	void ReadInt();
-	template <class READER, class T>
-	void ReadFlt();
-	template <class READER, class T>
-	void ReadStr();
-	template <class READER>
-	void ReadZeroStr();
-	template <class READER, class T>
-	void ReadBin();
-	template <class READER, class T>
-	void ReadArr();
-	template <class READER, class T>
-	void ReadMap();
-	template <class READER, class T>
-	void ReadExt();
-	template <class READER, uint32_t SIZE>
-	void ReadFixedExt();
-
-	inline void SkipCommon();
-
-
-private:
-	Buffer_t& m_Buf;
-	BufferIterator_t m_Cur;
-	bool m_IsDeadStream = false;
-	ReadResult_t m_Result = READ_SUCCESS;
-};
-
-template <class T>
-constexpr size_t header_size = 1 + sizeof(T);
-template <>
-constexpr size_t header_size<void> = 1;
-
-template <class BUFFER>
-template <class READER>
-void
-Dec<BUFFER>::ReadNil()
-{
-	assert(m_Cur.template get<uint8_t>() == 0xc0);
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_NIL;
-	[[maybe_unused]] constexpr Family type = MP_NIL;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		r.Value(m_Cur, ctype, nullptr);
-	}
-	++m_Cur;
-}
-
-template <class BUFFER>
-template <class READER>
-void
-Dec<BUFFER>::ReadBad()
-{
-	assert(m_Cur.template get<uint8_t>() == 0xc1);
-	AbandonDecoder(READ_BAD_MSGPACK);
-}
-
-template <class BUFFER>
-template <class READER>
-void
-Dec<BUFFER>::ReadBool()
-{
-	assert((m_Cur.template get<uint8_t>() & 0xfe) == 0xc2);
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_BOOL;
-	[[maybe_unused]] constexpr Family type = MP_BOOL;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		bool value = m_Cur.template get<uint8_t>() - 0xc2;
-		r.Value(m_Cur, ctype, value);
-	}
-	++m_Cur;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadUint()
-{
-	if constexpr (std::is_same_v<T, void>) {
-		assert(m_Cur.template get<uint8_t>() < 0x80);
-	} else {
-		assert((m_Cur.template get<uint8_t>() & 0xfc) == 0xcc);
-		assert(sizeof(T) ==
-			(1u << (m_Cur.template get<uint8_t>() - 0xcc)));
-	}
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_INT;
-	[[maybe_unused]] constexpr Family type = MP_INT;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if constexpr (!std::is_same_v<T, void>) {
-		if (!m_Buf.has(m_Cur, header_size<T>)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return;
-		}
-	}
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		uint64_t value;
-		if constexpr (std::is_same_v<T, void>) {
-			value = m_Cur.template get<uint8_t>();
-		} else {
-			BufferIterator_t step = m_Cur;
-			++step;
-			value = bswap(step.template get<T>());
-		}
-		r.Value(m_Cur, ctype, value);
-	}
-	if constexpr (std::is_same_v<T, void>)
-		++m_Cur;
-	else
-		m_Cur += header_size<T>;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadInt()
-{
-	if constexpr (std::is_same_v<T, void>) {
-		assert(m_Cur.template get<uint8_t>() >= 0xe0);
-	} else {
-		assert((m_Cur.template get<uint8_t>() & 0xfc) == 0xd0);
-		assert(sizeof(T) ==
-			(1u << (m_Cur.template get<uint8_t>() - 0xd0)));
-	}
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_INT;
-	[[maybe_unused]] constexpr Family type = MP_INT;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if constexpr (!std::is_same_v<T, void>) {
-		if (!m_Buf.has(m_Cur, header_size<T>)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return;
-		}
-	}
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		int64_t value;
-		if constexpr (std::is_same_v<T, void>) {
-			value = m_Cur.template get<int8_t>();
-		} else {
-			BufferIterator_t step = m_Cur;
-			++step;
-			using U = under_uint_t<T>;
-			U u = bswap(step.template get<U>());
-			value = static_cast<T>(u);
-		}
-		r.Value(m_Cur, ctype, value);
-	}
-	if constexpr (std::is_same_v<T, void>)
-		++m_Cur;
-	else
-		m_Cur += header_size<T>;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadFlt()
-{
-	assert((m_Cur.template get<uint8_t>() & 0xfe) == 0xca);
-	assert(sizeof(T) == (4u << ((m_Cur.template get<uint8_t>())&1)));
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_FLT;
-	[[maybe_unused]] constexpr Family type = MP_FLT;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if (!m_Buf.has(m_Cur, header_size<T>)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		T value;
-		BufferIterator_t step = m_Cur;
-		++step;
-		under_uint_t<T> x = bswap(step.template get<under_uint_t<T>>());
-		memcpy(&value, &x, sizeof(T));
-		r.Value(m_Cur, ctype, value);
-	}
-	m_Cur += header_size<T>;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadStr()
-{
-	if constexpr (std::is_same_v<T, void>) {
-		assert((m_Cur.template get<uint8_t>() & 0xe0) == 0xa0);
-	} else {
-		assert(m_Cur.template get<uint8_t>() >= 0xd9);
-		assert(m_Cur.template get<uint8_t>() <= 0xdb);
-		assert(sizeof(T) ==
-		       (1 << (m_Cur.template get<uint8_t>() - 0xd9)));
-	}
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_STR;
-	[[maybe_unused]] constexpr Family type = MP_STR;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if constexpr (!std::is_same_v<T, void>) {
-		if (!m_Buf.has(m_Cur, header_size<T>)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return;
-		}
-	}
-	uint32_t str_size;
-	if constexpr (std::is_same_v<T, void>) {
-		str_size = m_Cur.template get<uint8_t>() - 0xa0;
-	} else {
-		BufferIterator_t step = m_Cur;
-		++step;
-		str_size = bswap(step.template get<T>());
-	}
-	if (!m_Buf.has(m_Cur, header_size<T> + str_size)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		r.Value(m_Cur, ctype, StrValue{header_size<T>, str_size});
-	}
-	m_Cur += header_size<T> + str_size;
-}
-
-template <class BUFFER>
-template <class READER>
-void
-Dec<BUFFER>::ReadZeroStr()
-{
-	assert((m_Cur.template get<uint8_t>() & 0xe0) == 0xa0);
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_STR;
-	[[maybe_unused]] constexpr Family type = MP_STR;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		r.Value(m_Cur, ctype, StrValue{1, 0});
-	}
-	++m_Cur;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadBin()
-{
-	assert(m_Cur.template get<uint8_t>() >= 0xc4);
-	assert(m_Cur.template get<uint8_t>() <= 0xc6);
-	assert(sizeof(T) == (1 << (m_Cur.template get<uint8_t>() - 0xc4)));
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_BIN;
-	[[maybe_unused]] constexpr Family type = MP_BIN;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if constexpr (!std::is_same_v<T, void>) {
-		if (!m_Buf.has(m_Cur, header_size<T>)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return;
-		}
-	}
-	uint32_t bin_size;
-	BufferIterator_t step = m_Cur;
-	++step;
-	bin_size = bswap(step.template get<T>());
-	if (!m_Buf.has(m_Cur, header_size<T> + bin_size)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		r.Value(m_Cur, ctype, BinValue{header_size<T>, bin_size});
-	}
-	m_Cur += header_size<T> + bin_size;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadArr()
-{
-	if constexpr (std::is_same_v<T, void>) {
-		assert((m_Cur.template get<uint8_t>() & 0xf0) == 0x90);
-	} else {
-		assert((m_Cur.template get<uint8_t>() & 0xfe) == 0xdc);
-		assert(sizeof(T) ==
-		       (2 << (m_Cur.template get<uint8_t>() - 0xdc)));
-	}
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_ARR;
-	[[maybe_unused]] constexpr Family type = MP_ARR;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if constexpr (!std::is_same_v<T, void>) {
-		if (!m_Buf.has(m_Cur, header_size<T>)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return;
-		}
-	}
-
-	uint32_t arr_size;
-	if constexpr (std::is_same_v<T, void>) {
-		arr_size = m_Cur.template get<uint8_t>() - 0x90;
-	} else {
-		BufferIterator_t step = m_Cur;
-		++step;
-		arr_size = bswap(step.template get<T>());
-	}
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-		m_CurLevel->countdown += arr_size;
-	} else {
-		if (m_CurLevel == &m_Levels[MAX_DEPTH - 1]) {
-			r.MaxDepthReached();
-			AbortAndSkipRead(READ_MAX_DEPTH_REACHED);
-			m_CurLevel->countdown += arr_size;
-		} else {
-			++m_CurLevel;
-			m_CurLevel->countdown = arr_size;
-			m_CurLevel->stateMask = 0;
-			r.Value(m_Cur, ctype,
-				ArrValue{header_size<T>, arr_size});
-		}
-	}
-	if constexpr (std::is_same_v<T, void>)
-		++m_Cur;
-	else
-		m_Cur += header_size<T>;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadMap()
-{
-	if constexpr (std::is_same_v<T, void>) {
-		assert((m_Cur.template get<uint8_t>() & 0xf0) == 0x80);
-	} else {
-		assert((m_Cur.template get<uint8_t>() & 0xfe) == 0xde);
-		assert(sizeof(T) ==
-		       (2 << (m_Cur.template get<uint8_t>() - 0xde)));
-	}
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_MAP;
-	[[maybe_unused]] constexpr Family type = MP_MAP;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	if constexpr (!std::is_same_v<T, void>) {
-		if (!m_Buf.has(m_Cur, header_size<T>)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return;
-		}
-	}
-
-	uint32_t map_size;
-	if constexpr (std::is_same_v<T, void>) {
-		map_size = m_Cur.template get<uint8_t>() - 0x80;
-	} else {
-		BufferIterator_t step = m_Cur;
-		++step;
-		map_size = bswap(step.template get<T>());
-	}
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-		m_CurLevel->countdown += 2 * size_t(map_size);
-	} else {
-		if (m_CurLevel == &m_Levels[MAX_DEPTH - 1]) {
-			r.MaxDepthReached();
-			AbortAndSkipRead(READ_MAX_DEPTH_REACHED);
-			m_CurLevel->countdown += 2 * size_t(map_size);
-		} else {
-			++m_CurLevel;
-			m_CurLevel->countdown = 2 * size_t(map_size);
-			m_CurLevel->stateMask = 1;
-			r.Value(m_Cur, ctype,
-				MapValue{header_size<T>, map_size});
-		}
-	}
-	if constexpr (std::is_same_v<T, void>)
-		++m_Cur;
-	else
-		m_Cur += header_size<T>;
-}
-
-template <class BUFFER>
-template <class READER, class T>
-void
-Dec<BUFFER>::ReadExt()
-{
-	assert(m_Cur.template get<uint8_t>() >= 0xc7);
-	assert(m_Cur.template get<uint8_t>() <= 0xc9);
-	assert(sizeof(T) == (1 << (m_Cur.template get<uint8_t>() - 0xc7)));
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_EXT;
-	[[maybe_unused]] constexpr Family type = MP_EXT;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	constexpr size_t header_size = 2 + sizeof(T);
-	if (!m_Buf.has(m_Cur, header_size)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-	BufferIterator_t step = m_Cur;
-	++step;
-	uint32_t ext_size = bswap(step.template get<T>());
-	if (!m_Buf.has(m_Cur, header_size + ext_size)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-	step += sizeof(T);
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		int8_t ext_type = step.template get<int8_t>();
-		r.Value(m_Cur, ctype,
-			ExtValue{ext_type, header_size, ext_size});
-	}
-	m_Cur += header_size + ext_size;
-}
-
-template <class BUFFER>
-template <class READER, uint32_t SIZE>
-void
-Dec<BUFFER>::ReadFixedExt()
-{
-	assert(m_Cur.template get<uint8_t>() >= 0xd4);
-	assert(m_Cur.template get<uint8_t>() <= 0xd8);
-	assert(SIZE == (1 << (m_Cur.template get<uint8_t>() - 0xd4)));
-	[[maybe_unused]] constexpr compact::Family ctype = compact::MP_EXT;
-	[[maybe_unused]] constexpr Family type = MP_EXT;
-	READER& r = CurState().objHolder.template get<READER>();
-
-	constexpr size_t header_size = 2;
-	if (!m_Buf.has(m_Cur, header_size + SIZE)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-	BufferIterator_t step = m_Cur;
-
-	--m_CurLevel->countdown;
-	if constexpr ((READER::VALID_TYPES & type) == MP_NONE) {
-		r.WrongType(READER::VALID_TYPES, type);
-		AbortAndSkipRead(READ_WRONG_TYPE);
-	} else {
-		++step;
-		int8_t ext_type = step.template get<int8_t>();
-		r.Value(m_Cur, ctype,
-			ExtValue{ext_type, header_size, SIZE});
-	}
-	m_Cur += header_size + SIZE;
-}
-
-namespace details {
-
-struct TagInfo {
-	uint8_t header_size : 6;
-	uint8_t read_value_size : 2;
-	uint8_t read_value_str_like : 1;
-	uint8_t add_count : 5;
-	uint8_t read_value_arr_map : 2;
-
-	constexpr TagInfo(uint8_t a = 1, uint8_t b = 0, uint8_t c = 0,
-			  uint8_t d = 0, uint8_t e = 0)
-		: header_size(a), read_value_size(b), read_value_str_like(c),
-		  add_count(d), read_value_arr_map(e)
-	{}
-};
-
-static constexpr TagInfo tag_info[] = {
-	// fixed uint x 128
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	// fix map x 16
-	{1, 0, 0,  0}, {1, 0, 0,  2}, {1, 0, 0,  4}, {1, 0, 0,  6},
-	{1, 0, 0,  8}, {1, 0, 0, 10}, {1, 0, 0, 12}, {1, 0, 0, 14},
-	{1, 0, 0, 16}, {1, 0, 0, 18}, {1, 0, 0, 20}, {1, 0, 0, 22},
-	{1, 0, 0, 24}, {1, 0, 0, 26}, {1, 0, 0, 28}, {1, 0, 0, 30},
-	// fix arr x 16
-	{1, 0, 0,  0}, {1, 0, 0,  1}, {1, 0, 0,  2}, {1, 0, 0,  3},
-	{1, 0, 0,  4}, {1, 0, 0,  5}, {1, 0, 0,  6}, {1, 0, 0,  7},
-	{1, 0, 0,  8}, {1, 0, 0,  9}, {1, 0, 0, 10}, {1, 0, 0, 11},
-	{1, 0, 0, 12}, {1, 0, 0, 13}, {1, 0, 0, 14}, {1, 0, 0, 15},
-	// fix str x 32
-	{ 1}, { 2}, { 3}, { 4}, { 5}, { 6}, { 7}, { 8}, { 9}, {10},
-	{11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20},
-	{21}, {22}, {23}, {24}, {25}, {26}, {27}, {28}, {29}, {30},
-	{31}, {32},
-	// nil bas bool x 2
-	{1},{1},{1},{1},
-	// bin8 bin16 bin32
-	{1+1, 1, 1}, {1+2, 2, 1}, {1+4, 3, 1},
-	// ext8 ext16 ext32
-	{2+1, 1, 1}, {2+2, 2, 1}, {2+4, 3, 1},
-	// float double
-	{1+4}, {1+8},
-	// uint 8 - 64
-	{1+1}, {1+2}, {1+4}, {1+8},
-	// int 8 - 64
-	{1+1}, {1+2}, {1+4}, {1+8},
-	// fixext 1-16
-	{2+1}, {2+2}, {2+4}, {2+8}, {2+16},
-	// str8 str16 str32
-	{1+1, 1, 1}, {1+2, 2, 1}, {1+4, 3, 1},
-	// arr16 arr32
-	{1+2, 2, 0, 0, 1}, {1+4, 3, 0, 0, 1},
-	// map16 map32
-	{1+2, 2, 0, 0, 2}, {1+4, 3, 0, 0, 2},
-	// fix int x 32
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-	{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1},
-};
-static_assert(std::size(tag_info) == 256, "Smth was missed?");
-
-} // namespace details {
-
-template <class BUFFER>
-void
-Dec<BUFFER>::SkipCommon()
-{
-	uint8_t tag = m_Cur.template get<uint8_t>();
-	if (tag == 0xc1) {
-		AbandonDecoder(READ_BAD_MSGPACK);
-		return;
-	}
-	const details::TagInfo &info = details::tag_info[tag];
-	if (!m_Buf.has(m_Cur, info.header_size)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-	size_t value;
-	switch (info.read_value_size) {
-		case 0: value = 0; break;
-		case 1:
-			value = bswap((m_Cur + 1).template get<uint8_t>());
-			break;
-		case 2:
-			value = bswap((m_Cur + 1).template get<uint16_t>());
-			break;
-		case 3:
-			value = bswap((m_Cur + 1).template get<uint32_t>());
-			break;
-		default:
-			tnt::unreachable();
-	}
-	size_t obj_size = info.header_size + value * info.read_value_str_like;
-	if (!m_Buf.has(m_Cur, obj_size)) {
-		m_Result = m_Result | READ_NEED_MORE;
-		return;
-	}
-	size_t add_count = info.add_count + value * info.read_value_arr_map;
-	m_CurLevel->countdown += add_count;
-	--m_CurLevel->countdown;
-	m_Cur += obj_size;
-}
-
-template <class DEC, class READER, class SEQUENCE>
-struct ReaderMap;
-
-template <class DEC, class READER, size_t... N>
-struct ReaderMap<DEC, READER, tnt::iseq<N...>> {
-	using Transition_t = typename DEC::Transition_t;
-	template <size_t I>
-	static constexpr Transition_t get()
-	{
-		if constexpr (I <= 0x7f)
-			return &DEC::template ReadUint<READER, void>;
-		else if constexpr (I <= 0x8f )
-			return &DEC::template ReadMap<READER, void>;
-		else if constexpr (I <= 0x9f )
-			return &DEC::template ReadArr<READER, void>;
-		else if constexpr (I <= 0xa0 )
-			return &DEC::template ReadZeroStr<READER>;
-		else if constexpr (I <= 0xbf )
-			return &DEC::template ReadStr<READER, void>;
-		else if constexpr (I <= 0xc0)
-			return &DEC::template ReadNil<READER>;
-		else if constexpr (I <= 0xc1)
-			return &DEC::template ReadBad<READER>;
-		else if constexpr (I <= 0xc3)
-			return &DEC::template ReadBool<READER>;
-		else if constexpr (I <= 0xc4)
-			return &DEC::template ReadBin<READER, uint8_t>;
-		else if constexpr (I <= 0xc5)
-			return &DEC::template ReadBin<READER, uint16_t>;
-		else if constexpr (I <= 0xc6)
-			return &DEC::template ReadBin<READER, uint32_t>;
-		else if constexpr (I <= 0xc7)
-			return &DEC::template ReadExt<READER, uint8_t>;
-		else if constexpr (I <= 0xc8)
-			return &DEC::template ReadExt<READER, uint16_t>;
-		else if constexpr (I <= 0xc9)
-			return &DEC::template ReadExt<READER, uint32_t>;
-		else if constexpr (I <= 0xca)
-			return &DEC::template ReadFlt<READER, float>;
-		else if constexpr (I <= 0xcb)
-			return &DEC::template ReadFlt<READER, double>;
-		else if constexpr (I <= 0xcc)
-			return &DEC::template ReadUint<READER, uint8_t>;
-		else if constexpr (I <= 0xcd)
-			return &DEC::template ReadUint<READER, uint16_t>;
-		else if constexpr (I <= 0xce)
-			return &DEC::template ReadUint<READER, uint32_t>;
-		else if constexpr (I <= 0xcf)
-			return &DEC::template ReadUint<READER, uint64_t>;
-		else if constexpr (I <= 0xd0)
-			return &DEC::template ReadInt<READER, int8_t>;
-		else if constexpr (I <= 0xd1)
-			return &DEC::template ReadInt<READER, int16_t>;
-		else if constexpr (I <= 0xd2)
-			return &DEC::template ReadInt<READER, int32_t>;
-		else if constexpr (I <= 0xd3)
-			return &DEC::template ReadInt<READER, int64_t>;
-		else if constexpr (I <= 0xd8)
-			return &DEC::template ReadFixedExt<READER, 1u << (I - 0xd4)>;
-		else if constexpr (I <= 0xd9)
-			return &DEC::template ReadStr<READER, uint8_t>;
-		else if constexpr (I <= 0xda)
-			return &DEC::template ReadStr<READER, uint16_t>;
-		else if constexpr (I <= 0xdb)
-			return &DEC::template ReadStr<READER, uint32_t>;
-		else if constexpr (I <= 0xdc)
-			return &DEC::template ReadArr<READER, uint16_t>;
-		else if constexpr (I <= 0xdd)
-			return &DEC::template ReadArr<READER, uint32_t>;
-		else if constexpr (I <= 0xde)
-			return &DEC::template ReadMap<READER, uint16_t>;
-		else if constexpr (I <= 0xdf)
-			return &DEC::template ReadMap<READER, uint32_t>;
-		else
-			return &DEC::template ReadInt<READER, void>;
-		static_assert(I <= 0xff, "Wtf?");
-	}
-	static constexpr Transition_t transitions[256] = {get<N>()...};
-};
-
-template <class BUFFER>
-template<class READER, class... ARGS>
-void
-Dec<BUFFER>::FillState(State &st, ARGS&&... args)
-{
-	// We never use the second state on top level.
-	assert(&st != &m_Levels[0].state[1]);
-	using Reader_t = std::decay_t<READER>;
-	st.objHolder.template create<Reader_t>(std::forward<ARGS>(args)...);
-	st.transitions = ReaderMap<Dec_t, Reader_t,
-		tnt::make_iseq<256>>::transitions;
-	st.storeEndIterator =
-		st.objHolder.template get<Reader_t>().StoreEndIterator();
-}
-
-template <class BUFFER>
-void
-Dec<BUFFER>::FillSkipState(State &st, BufferIterator_t *save_end)
-{
-#define REP16(x) x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x
-#define REP16_DELAYED(x) REP16(x)
-#define REP256(x) REP16(REP16_DELAYED(x))
-	static constexpr Transition_t transit[] = {REP256(&Dec_t::SkipCommon)};
-	static_assert(std::size(transit) == 256, "Miss smth?");
-#undef REP256
-#undef REP16_DELAYED
-#undef REP16
-	st.transitions = transit;
-	st.storeEndIterator = save_end;
-}
-
-template <class BUFFER>
-void
-Dec<BUFFER>::AbortAndSkipRead(ReadResult_t error)
-{
-	m_Result = m_Result | error;
-	while (m_CurLevel != m_Levels) {
-		size_t tmp = m_CurLevel->countdown;
-		m_CurLevel->state[0].objHolder.destroy();
-		m_CurLevel->state[1].objHolder.destroy();
-		--m_CurLevel;
-		m_CurLevel->countdown += tmp;
-	}
-	m_CurLevel->stateMask = 0;
-}
-
-template <class BUFFER>
-void
-Dec<BUFFER>::AbandonDecoder(ReadResult_t error)
-{
-	m_IsDeadStream = true;
-	m_Result = m_Result | error;
-}
-
-template <class BUFFER>
-template <class T, class... U>
-void Dec<BUFFER>::SetReader(bool second, U&&... u)
-{
-	FillState<T>(m_CurLevel->state[second], std::forward<U>(u)...);
-}
-
-template <class BUFFER>
-template <class T>
-void Dec<BUFFER>::SetReader(bool second, T&& t)
-{
-	FillState<T>(m_CurLevel->state[second], std::forward<T>(t));
-}
-
-template <class BUFFER>
-void Dec<BUFFER>::Skip(BufferIterator_t *saveEnd)
-{
-	FillSkipState(m_CurLevel->state[0], saveEnd);
-	FillSkipState(m_CurLevel->state[1], saveEnd);
-}
-
-template <class BUFFER>
-void Dec<BUFFER>::SetPosition(BufferIterator_t &itr)
-{
-	m_Cur = itr;
-}
-
-
-template <class BUFFER>
-ReadResult_t
-Dec<BUFFER>::Read()
-{
-	if (m_IsDeadStream)
-		return m_Result;
-	m_Result = m_Result & ~READ_NEED_MORE;
-	if (m_CurLevel->countdown == 0) {
-		m_CurLevel->countdown = 1;
-		m_Result = READ_SUCCESS;
-	}
-	while (true) {
-		if (!m_Buf.has(m_Cur, 1)) {
-			m_Result = m_Result | READ_NEED_MORE;
-			return m_Result;
-		}
-		uint8_t tag = m_Cur.template get<uint8_t>();
-		(this->*(CurState().transitions[tag]))();
-		if (m_IsDeadStream || (m_Result & READ_NEED_MORE))
-			return m_Result;
-		while (m_CurLevel->countdown == 0) {
-			m_CurLevel->state[0].objHolder.destroy();
-			m_CurLevel->state[1].objHolder.destroy();
-			if (m_CurLevel == m_Levels)
-				return m_Result;
-			--m_CurLevel;
-			if (LastState().storeEndIterator != nullptr)
-				*LastState().storeEndIterator = m_Cur;
-		}
-	}
-}
-
-} // namespace mpp {
diff --git a/test/EncDecTest.cpp b/test/EncDecTest.cpp
index 26498a3da..defc45831 100644
--- a/test/EncDecTest.cpp
+++ b/test/EncDecTest.cpp
@@ -180,189 +180,6 @@ test_type_visual()
 					    compact::MP_NIL>{} << ")\n";
 }
 
-struct TestArrStruct {
-	size_t parsed_arr_size;
-	double dbl;
-	float flt;
-	char str[12];
-	std::nullptr_t nil;
-	bool b;
-};
-
-
-struct ArrValueReader : mpp::DefaultErrorHandler {
-	using Buffer_t = tnt::Buffer<16 * 1024>;
-	using BufferIterator_t = typename Buffer_t::iterator;
-	explicit ArrValueReader(TestArrStruct& a) : arr(a) {}
-	static constexpr mpp::Family VALID_TYPES = mpp::MP_FLT |
-		mpp::MP_STR | mpp::MP_NIL | mpp::MP_BOOL;
-	template <class T>
-	void Value(const BufferIterator_t&, mpp::compact::Family, T v)
-	{
-		using A = TestArrStruct;
-		static constexpr std::tuple map(&A::dbl, &A::flt, &A::nil, &A::b);
-		auto ptr = std::get<std::decay_t<T> A::*>(map);
-		arr.*ptr = v;
-	}
-	void Value(BufferIterator_t& itr, mpp::compact::Family, mpp::StrValue v)
-	{
-		BufferIterator_t tmp = itr;
-		tmp += v.offset;
-		char *dst = arr.str;
-		while (v.size) {
-			*dst++ = *tmp;
-			++tmp;
-			--v.size;
-		}
-		*dst = 0;
-	}
-
-	BufferIterator_t* StoreEndIterator() { return nullptr; }
-	TestArrStruct& arr;
-};
-
-struct ArrReader : mpp::SimpleReaderBase<tnt::Buffer<16 * 1024>, mpp::MP_ARR> {
-	using Buffer_t = tnt::Buffer<16 * 1024>;
-	using BufferIterator_t = typename Buffer_t::iterator;
-	ArrReader(TestArrStruct& a, mpp::Dec<Buffer_t>& d) : arr(a), dec(d) {}
-	void Value(const BufferIterator_t&, mpp::compact::Family, mpp::ArrValue v)
-	{
-		arr.parsed_arr_size = v.size;
-		dec.SetReader(false, ArrValueReader{arr});
-	}
-
-	TestArrStruct& arr;
-	mpp::Dec<Buffer_t>& dec;
-};
-
-namespace example {
-
-using Buffer_t = tnt::Buffer<16 * 1024>;
-using BufferIterator_t = typename Buffer_t::iterator;
-
-struct TestMapStruct {
-	bool boo;
-	char str[12];
-	size_t str_size;
-	int arr[3];
-	size_t arr_size;
-};
-
-struct MapKeyReader : mpp::SimpleReaderBase<Buffer_t, mpp::MP_INT> {
-	MapKeyReader(mpp::Dec<Buffer_t>& d, TestMapStruct& m) : dec(d), map(m) {}
-
-	void Value(const BufferIterator_t&, mpp::compact::Family, uint64_t k)
-	{
-		using map_t = TestMapStruct;
-		using Boo_t = mpp::SimpleReader<Buffer_t, mpp::MP_BOOL, bool>;
-		using Str_t = mpp::SimpleStrReader<Buffer_t, sizeof(map_t{}.str)>;
-		using Arr_t = mpp::SimpleArrReader
-			<mpp::Dec<Buffer_t>,
-			Buffer_t,
-			sizeof(map_t{}.arr) / sizeof(map_t{}.arr[0]),
-			mpp::MP_INT,
-			int
-			>;
-		switch (k) {
-		case 10:
-			dec.SetReader(true, Boo_t{map.boo});
-			break;
-		case 11:
-			dec.SetReader(true, Str_t{map.str, map.str_size});
-			break;
-		case 12:
-			dec.SetReader(true, Arr_t{dec, map.arr, map.arr_size});
-			break;
-		default:
-			dec.AbortAndSkipRead();
-		}
-	}
-
-	mpp::Dec<Buffer_t>& dec;
-	TestMapStruct& map;
-};
-
-
-struct MapReader : mpp::SimpleReaderBase<tnt::Buffer<16 * 1024>, mpp::MP_MAP> {
-	MapReader(mpp::Dec<Buffer_t>& d, TestMapStruct& m) : dec(d), map(m) {}
-
-	void Value(const BufferIterator_t&, mpp::compact::Family, mpp::MapValue)
-	{
-		dec.SetReader(false, MapKeyReader{dec, map});
-	}
-
-	mpp::Dec<Buffer_t>& dec;
-	TestMapStruct& map;
-};
-
-} // namespace example {
-
-template <class T>
-struct IntVectorValueReader : mpp::DefaultErrorHandler {
-	using Buffer_t = tnt::Buffer<16 * 1024>;
-	using BufferIterator_t = typename Buffer_t::iterator;
-	explicit IntVectorValueReader(std::vector<T>& v) : vec(v) {}
-	static constexpr mpp::Family VALID_TYPES = mpp::MP_INT;
-	template <class V>
-	void Value(const BufferIterator_t&, mpp::compact::Family, V v)
-	{
-		vec.push_back(v);
-	}
-
-	BufferIterator_t* StoreEndIterator() { return nullptr; }
-	std::vector<T>& vec;
-};
-
-template <class T>
-struct IntVectorReader : mpp::SimpleReaderBase<tnt::Buffer<16 * 1024>, mpp::MP_ARR> {
-	static_assert(std::is_integral_v<T>);
-	static_assert(!std::is_same_v<T, bool>);
-	using Buffer_t = tnt::Buffer<16 * 1024>;
-	using BufferIterator_t = typename Buffer_t::iterator;
-	IntVectorReader(std::vector<T>& v, mpp::Dec<Buffer_t>& d) : vec(v), dec(d) {}
-	void Value(const BufferIterator_t&, mpp::compact::Family, mpp::ArrValue v)
-	{
-		vec.reserve(v.size);
-		dec.SetReader(false, IntVectorValueReader{vec});
-	}
-	std::vector<T>& vec;
-	mpp::Dec<Buffer_t>& dec;
-};
-
-template <class T, class U>
-struct IntMapValueReader : mpp::DefaultErrorHandler {
-	using Buffer_t = tnt::Buffer<16 * 1024>;
-	using BufferIterator_t = typename Buffer_t::iterator;
-	IntMapValueReader(std::map<T, U>& m, mpp::Dec<Buffer_t>& d) : map(m), dec(d) {}
-	static constexpr mpp::Family VALID_TYPES = mpp::MP_INT;
-	template <class V>
-	void Value(const BufferIterator_t&, mpp::compact::Family, V v)
-	{
-		auto res = map.template emplace(v, 0);
-		using ValueReader_t = mpp::SimpleReader<Buffer_t, VALID_TYPES, U>;
-		dec.SetReader(true, ValueReader_t{res.first->second});
-	}
-
-	BufferIterator_t* StoreEndIterator() { return nullptr; }
-	std::map<T, U>& map;
-	mpp::Dec<Buffer_t>& dec;
-};
-
-template <class T, class U>
-struct IntMapReader : mpp::SimpleReaderBase<tnt::Buffer<16 * 1024>, mpp::MP_MAP> {
-	static_assert(tnt::is_integer_v<T>);
-	static_assert(tnt::is_integer_v<U>);
-	using Buffer_t = tnt::Buffer<16 * 1024>;
-	using BufferIterator_t = typename Buffer_t::iterator;
-	IntMapReader(std::map<T, U>& m, mpp::Dec<Buffer_t>& d) : map(m), dec(d) {}
-	void Value(const BufferIterator_t&, mpp::compact::Family, mpp::MapValue)
-	{
-		dec.SetReader(false, IntMapValueReader{map, dec});
-	}
-	std::map<T, U>& map;
-	mpp::Dec<Buffer_t>& dec;
-};
-
 enum E1 {
 	ZERO1 = 0,
 	FOR_BILLIONS = 4000000000u,
@@ -838,178 +655,6 @@ test_basic()
 	std::map<int, int> read_map;
 	fail_unless(mpp::decode(run, read_map));
 	fail_unless(are_equal(read_map, add_map));
-
-	mpp::Dec<Buf_t> dec(buf);
-	{
-		int val = 15478;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_INT, int>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != 0);
-	}
-	{
-		int val = 15478;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_INT, int>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != 10);
-	}
-	{
-		unsigned short val = 15478;
-		mpp::SimpleReader<Buf_t, mpp::MP_NUM, unsigned short> r{val};
-		dec.SetReader(false, r);
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != 200);
-	}
-	for (uint64_t exp : {2000ull, 2000000ull, 4000000000ull, 4000000000ull, 20000000000ull})
-	{
-		uint64_t val = 15478;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_INT, uint64_t>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != exp);
-	}
-	for (int32_t exp : {-1, -100, -100, -1000})
-	{
-		int32_t val = 15478;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_INT, int32_t>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != exp);
-	}
-	for (double exp : {1., 2.})
-	{
-		double val = 15478;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_FLT, double>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != exp);
-	}
-	for (int32_t exp : {11, 12, -13, 100500, 100501})
-	{
-		int32_t val = 15478;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_INT, int32_t>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != exp);
-	}
-	for (bool  exp : {false, true})
-	{
-		bool val = !exp;
-		dec.SetReader(false, mpp::SimpleReader<Buf_t, mpp::MP_BOOL, bool>{val});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(val != exp);
-	}
-	{
-		constexpr size_t S = 16;
-		char str[S];
-		size_t size;
-		dec.SetReader(false, mpp::SimpleStrReader<Buf_t, S - 1>{str, size});
-		mpp::ReadResult_t res = dec.Read();
-		str[size] = 0;
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(size != 3);
-		fail_if(strcmp(str, "abc") != 0);
-	}
-	{
-		constexpr size_t S = 16;
-		char str[S];
-		size_t size;
-		dec.SetReader(false, mpp::SimpleStrReader<Buf_t, S - 1>{str, size});
-		mpp::ReadResult_t res = dec.Read();
-		str[size] = 0;
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(size != 4);
-		fail_if(strcmp(str, "defg") != 0);
-	}
-	{
-		constexpr size_t S = 16;
-		char str[S];
-		size_t size;
-		dec.SetReader(false, mpp::SimpleStrReader<Buf_t, S - 1>{str, size});
-		mpp::ReadResult_t res = dec.Read();
-		str[size] = 0;
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(size != 10);
-		fail_if(strcmp(str, "1234567890") != 0);
-	}
-	{
-		TestArrStruct arr = {};
-		dec.SetReader(false, ArrReader{arr, dec});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(arr.parsed_arr_size != 0);
-
-	}
-	{
-		TestArrStruct arr = {};
-		dec.SetReader(false, ArrReader{arr, dec});
-		mpp::ReadResult_t res = dec.Read();
-		fail_if(res != mpp::READ_SUCCESS);
-		fail_if(arr.parsed_arr_size != 5);
-		fail_if(arr.dbl != 1.);
-		fail_if(arr.flt != 2.f);
-		fail_if(strcmp(arr.str, "test") != 0);
-		fail_if(arr.nil != nullptr);
-		fail_if(arr.b != false);
-
-	}
-	{
-		using namespace example;
-		TestMapStruct map = {};
-		dec.SetReader(false, MapReader{dec, map});
-		mpp::ReadResult_t res = dec.Read();
-		fail_unless(res == mpp::READ_SUCCESS);
-		fail_unless(map.boo == true);
-		fail_unless(strcmp(map.str, "val") == 0);
-		fail_unless(map.arr_size == 3);
-		fail_unless(map.arr[0] == 1);
-		fail_unless(map.arr[1] == 2);
-		fail_unless(map.arr[2] == 3);
-	}
-	dec.Skip();
-	fail_unless(dec.Read() == mpp::READ_SUCCESS);
-	fail_unless(dec.Read() == mpp::READ_SUCCESS);
-	{
-		std::vector<int> vec;
-		dec.SetReader(false, IntVectorReader{vec, dec});
-		mpp::ReadResult_t res = dec.Read();
-		fail_unless(res == mpp::READ_SUCCESS);
-		fail_unless(vec.size() == 3);
-		fail_unless(vec[0] == 1);
-		fail_unless(vec[1] == 2);
-		fail_unless(vec[2] == 3);
-	}
-	{
-		std::vector<short int> vec;
-		dec.SetReader(false, IntVectorReader{vec, dec});
-		mpp::ReadResult_t res = dec.Read();
-		fail_unless(res == mpp::READ_SUCCESS);
-		fail_unless(vec.size() == 3);
-		fail_unless(vec[0] == 4);
-		fail_unless(vec[1] == 5);
-		fail_unless(vec[2] == 6);
-	}
-	{
-		std::vector<uint8_t> vec;
-		dec.SetReader(false, IntVectorReader{vec, dec});
-		mpp::ReadResult_t res = dec.Read();
-		fail_unless(res == mpp::READ_SUCCESS);
-		fail_unless(vec.size() == 2);
-		fail_unless(vec[0] == 7);
-		fail_unless(vec[1] == 8);
-	}
-	{
-		std::map<int, int> map;
-		dec.SetReader(false, IntMapReader{map, dec});
-		mpp::ReadResult_t res = dec.Read();
-		fail_unless(res == mpp::READ_SUCCESS);
-		fail_unless(map.size() == 2);
-		fail_unless(map[1] == 2);
-		fail_unless(map[3] == 4);
-	}
 }
 
 struct JustClass {

From 067ce9265c29320228e485cdcacf6163a6615cb0 Mon Sep 17 00:00:00 2001
From: Andrey Saranchin <Andrey22102001@gmail.com>
Date: Wed, 10 Jan 2024 18:18:43 +0300
Subject: [PATCH 2/4] build: support -Wconversion warning

Some compound assignments called on non-standard trivial types (e.g,
short int) were split into operators and assignments because of strange
gcc behavior (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56908).
---
 CMakeLists.txt                  |  1 +
 src/Buffer/Buffer.hpp           | 16 ++++----
 src/Client/Connection.hpp       | 15 +++----
 src/Client/LibevNetProvider.hpp |  5 ++-
 src/Client/RequestEncoder.hpp   | 50 +++++++++++-----------
 src/Client/ResponseDecoder.hpp  |  2 +-
 src/Client/Stream.hpp           |  2 +-
 src/Client/UnixPlainStream.hpp  |  2 +-
 src/Client/UnixSSLStream.hpp    |  4 +-
 src/Client/UnixStream.hpp       |  3 +-
 src/Utils/Base64.hpp            |  9 ++--
 src/Utils/Mempool.hpp           |  3 +-
 src/Utils/ObjHolder.hpp         | 73 ---------------------------------
 src/Utils/Sha1.hpp              |  5 ++-
 src/Utils/Timer.hpp             |  2 +-
 src/mpp/Constants.hpp           |  4 +-
 src/mpp/Dec.hpp                 |  8 ++--
 src/mpp/Enc.hpp                 | 17 ++++----
 src/mpp/Rules.hpp               |  8 ++--
 test/Base64UnitTest.cpp         | 29 ++++++-------
 test/BufferUnitTest.cpp         | 24 +++++------
 test/ClientTest.cpp             |  8 ++--
 test/EncDecTest.cpp             | 49 +++++++++++-----------
 test/ListUnitTest.cpp           | 10 ++---
 test/MempoolUnitTest.cpp        |  6 +--
 test/RulesUnitTest.cpp          |  2 +-
 test/TraitsUnitTest.cpp         |  2 +-
 test/Utils/System.hpp           |  4 +-
 28 files changed, 151 insertions(+), 212 deletions(-)
 delete mode 100644 src/Utils/ObjHolder.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 059bcc533..65009073c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -141,6 +141,7 @@ FUNCTION (TNTCXX_TEST)
     TARGET_COMPILE_DEFINITIONS(${TNTCXX_TEST_NAME} PRIVATE ${TNTCXX_TEST_DEFINES})
     IF (${TNTCXX_TEST_TYPE} STREQUAL "ctest")
         ADD_TEST(NAME ${TNTCXX_TEST_NAME} COMMAND ${TNTCXX_TEST_NAME})
+	TARGET_COMPILE_OPTIONS(${TNTCXX_TEST_NAME} PRIVATE -Wconversion)
     ENDIF()
 ENDFUNCTION()
 
diff --git a/src/Buffer/Buffer.hpp b/src/Buffer/Buffer.hpp
index 647b121ba..e2cdfa465 100644
--- a/src/Buffer/Buffer.hpp
+++ b/src/Buffer/Buffer.hpp
@@ -801,7 +801,7 @@ Buffer<N, allocator>::dropBack(size_t size)
 	assert(!m_blocks.isEmpty());
 
 	Block *block = &m_blocks.last();
-	size_t left_in_block = m_end - block->begin();
+	size_t left_in_block = static_cast<size_t>(m_end - block->begin());
 
 	/* Do not delete the block if it is empty after drop. */
 	while (TNT_UNLIKELY(size > left_in_block)) {
@@ -842,7 +842,7 @@ Buffer<N, allocator>::dropFront(size_t size)
 	assert(!m_blocks.isEmpty());
 
 	Block *block = &m_blocks.first();
-	size_t left_in_block = block->end() - m_begin;
+	size_t left_in_block = static_cast<size_t>(block->end() - m_begin);
 
 	while (TNT_UNLIKELY(size >= left_in_block)) {
 #ifndef NDEBUG
@@ -918,8 +918,8 @@ Buffer<N, allocator>::insert(const iterator &itr, size_t size)
 	 */
 #define src_block_begin ((src_block == itr.getBlock()) ? itr.m_position : src_block->begin())
 	/* Firstly move data in blocks. */
-	size_t left_in_dst_block = m_end - dst_block->begin();
-	size_t left_in_src_block = src_block_end - src_block_begin;
+	size_t left_in_dst_block = static_cast<size_t>(m_end - dst_block->begin());
+	size_t left_in_src_block = static_cast<size_t>(src_block_end - src_block_begin);
 	if (left_in_dst_block > left_in_src_block) {
 		src = src_block_begin;
 		dst = m_end - left_in_src_block;
@@ -943,7 +943,7 @@ Buffer<N, allocator>::insert(const iterator &itr, size_t size)
 				break;
 			src_block = &src_block->prev();
 			src = src_block->end() - left_in_dst_block;
-			left_in_src_block = src_block->end() - src_block_begin;
+			left_in_src_block = static_cast<size_t>(src_block->end() - src_block_begin);
 			dst = dst_block->begin();
 			copy_chunk_sz = left_in_dst_block;
 		} else {
@@ -978,14 +978,14 @@ Buffer<N, allocator>::release(const iterator &itr, size_t size)
 	size_t step = size;
 	assert(src_block->end() > src);
 	while (step >= (size_t)(src_block->end() - src)) {
-		step -= src_block->end() - src;
+		step -= static_cast<size_t>(src_block->end() - src);
 		src_block = &src_block->next();
 		src = src_block->begin();
 	}
 	src += step;
 	/* Firstly move data in blocks. */
-	size_t left_in_dst_block = dst_block->end() - dst;
-	size_t left_in_src_block = src_block->end() - src;
+	size_t left_in_dst_block = static_cast<size_t>(dst_block->end() - dst);
+	size_t left_in_src_block = static_cast<size_t>(src_block->end() - src);
 	size_t copy_chunk_sz = std::min(left_in_src_block, left_in_dst_block);
 	for (;;) {
 		std::memmove(dst, src, copy_chunk_sz);
diff --git a/src/Client/Connection.hpp b/src/Client/Connection.hpp
index 7715a715c..79ddc56cd 100644
--- a/src/Client/Connection.hpp
+++ b/src/Client/Connection.hpp
@@ -42,7 +42,7 @@
 /** rid == request id */
 typedef size_t rid_t;
 
-static constexpr size_t CONN_READAHEAD = 64 * 1024;
+static constexpr ssize_t CONN_READAHEAD = 64 * 1024;
 static constexpr size_t IOVEC_MAX_SIZE = 32;
 
 struct ConnectionError {
@@ -249,7 +249,7 @@ class Connection
 
 private:
 	ConnectionImpl<BUFFER, NetProvider> *impl;
-	static constexpr size_t GC_STEP_CNT = 100;
+	static constexpr int GC_STEP_CNT = 100;
 
 	template <class T>
 	rid_t insert(const T &tuple, uint32_t space_id);
@@ -549,8 +549,9 @@ processResponse(Connection<BUFFER, NetProvider> &conn,
 		std::abort();
 
 	}
-	response.size += MP_RESPONSE_SIZE;
-	if (! conn.impl->inBuf.has(conn.impl->endDecoded, response.size)) {
+	response.size += static_cast<int>(MP_RESPONSE_SIZE);
+	uint32_t size = static_cast<uint32_t>(response.size);
+	if (! conn.impl->inBuf.has(conn.impl->endDecoded, size)) {
 		//Response was received only partially. Reset decoder position
 		//to the start of response to make this function re-entered.
 		conn.impl->dec.reset(conn.impl->endDecoded);
@@ -558,7 +559,7 @@ processResponse(Connection<BUFFER, NetProvider> &conn,
 	}
 	if (conn.impl->dec.decodeResponse(response) != 0) {
 		conn.setError("Failed to decode response, skipping bytes..");
-		conn.impl->endDecoded += response.size;
+		conn.impl->endDecoded += size;
 		return DECODE_ERR;
 	}
 	LOG_DEBUG("Header: sync=", response.header.sync, ", code=",
@@ -569,7 +570,7 @@ processResponse(Connection<BUFFER, NetProvider> &conn,
 		conn.impl->futures.insert({response.header.sync,
 					   std::move(response)});
 	}
-	conn.impl->endDecoded += response.size;
+	conn.impl->endDecoded += size;
 	inputBufGC(conn);
 	return DECODE_SUCC;
 }
@@ -594,7 +595,7 @@ decodeGreeting(Connection<BUFFER, NetProvider> &conn)
 	char hex_salt[Iproto::MAX_SALT_SIZE * 2 + 1];
 	const char *hex = "0123456789abcdef";
 	for (size_t i = 0; i < conn.impl->greeting.salt_size; i++) {
-		uint8_t u = conn.impl->greeting.salt[i];
+		uint8_t u = static_cast<uint8_t>(conn.impl->greeting.salt[i]);
 		hex_salt[i * 2] = hex[u / 16];
 		hex_salt[i * 2 + 1] = hex[u % 16];
 	}
diff --git a/src/Client/LibevNetProvider.hpp b/src/Client/LibevNetProvider.hpp
index 1da6f9527..e9a2f590f 100644
--- a/src/Client/LibevNetProvider.hpp
+++ b/src/Client/LibevNetProvider.hpp
@@ -129,7 +129,8 @@ connectionReceive(Connection<BUFFER,  LibevNetProvider<BUFFER, Stream>> &conn)
 	size_t iov_cnt = buf.getIOV(itr, iov, IOVEC_MAX_SIZE);
 
 	ssize_t rcvd = conn.get_strm().recv(iov, iov_cnt);
-	hasNotRecvBytes(conn, CONN_READAHEAD - (rcvd < 0 ? 0 : rcvd));
+	size_t bytes = static_cast<size_t>(CONN_READAHEAD - (rcvd < 0 ? 0 : rcvd));
+	hasNotRecvBytes(conn, bytes);
 	if (rcvd < 0) {
 		conn.setError(std::string("Failed to receive response: ") +
 			       strerror(errno), errno);
@@ -213,7 +214,7 @@ connectionSend(Connection<BUFFER,  LibevNetProvider<BUFFER, Stream>> &conn)
 			assert(conn.get_strm().has_status(SS_NEED_EVENT_FOR_WRITE));
 			return 1;
 		} else {
-			hasSentBytes(conn, sent);
+			hasSentBytes(conn, static_cast<size_t>(sent));
 		}
 	}
 	/* All data from connection has been successfully written. */
diff --git a/src/Client/RequestEncoder.hpp b/src/Client/RequestEncoder.hpp
index 40fda228c..a4579374d 100644
--- a/src/Client/RequestEncoder.hpp
+++ b/src/Client/RequestEncoder.hpp
@@ -97,7 +97,7 @@ class RequestEncoder {
 			  const Greeting &greet);
 
 	/** Sync value is used as request id. */
-	static size_t getSync() { return sync; }
+	static size_t getSync() { return static_cast<size_t>(sync); }
 	static constexpr size_t PREHEADER_SIZE = 5;
 private:
 	void encodeHeader(int request);
@@ -124,9 +124,9 @@ RequestEncoder<BUFFER>::encodePing()
 	m_Buf.write(uint32_t{0});
 	encodeHeader(Iproto::PING);
 	mpp::encode(m_Buf, mpp::as_map(std::make_tuple()));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -142,9 +142,9 @@ RequestEncoder<BUFFER>::encodeInsert(const T &tuple, uint32_t space_id)
 	mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
 		MPP_AS_CONST(Iproto::SPACE_ID), space_id,
 		MPP_AS_CONST(Iproto::TUPLE), tuple)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -160,9 +160,9 @@ RequestEncoder<BUFFER>::encodeReplace(const T &tuple, uint32_t space_id)
 	mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
 		MPP_AS_CONST(Iproto::SPACE_ID), space_id,
 		MPP_AS_CONST(Iproto::TUPLE), tuple)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -180,9 +180,9 @@ RequestEncoder<BUFFER>::encodeDelete(const T &key, uint32_t space_id,
 		MPP_AS_CONST(Iproto::SPACE_ID), space_id,
 		MPP_AS_CONST(Iproto::INDEX_ID), index_id,
 		MPP_AS_CONST(Iproto::KEY), key)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -201,9 +201,9 @@ RequestEncoder<BUFFER>::encodeUpdate(const K &key, const T &tuple,
 		MPP_AS_CONST(Iproto::INDEX_ID), index_id,
 		MPP_AS_CONST(Iproto::KEY), key,
 		MPP_AS_CONST(Iproto::TUPLE), tuple)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -222,9 +222,9 @@ RequestEncoder<BUFFER>::encodeUpsert(const T &tuple, const O &ops,
 		MPP_AS_CONST(Iproto::INDEX_BASE), index_base,
 		MPP_AS_CONST(Iproto::OPS), ops,
 		MPP_AS_CONST(Iproto::TUPLE), tuple)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -247,9 +247,9 @@ RequestEncoder<BUFFER>::encodeSelect(const T &key,
 		MPP_AS_CONST(Iproto::OFFSET), offset,
 		MPP_AS_CONST(Iproto::ITERATOR), iterator,
 		MPP_AS_CONST(Iproto::KEY), key)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -266,9 +266,9 @@ RequestEncoder<BUFFER>::encodeExecute(const std::string& statement, const T& par
 		MPP_AS_CONST(Iproto::SQL_TEXT), statement,
 		MPP_AS_CONST(Iproto::SQL_BIND), parameters,
 		MPP_AS_CONST(Iproto::OPTIONS), std::make_tuple())));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -285,9 +285,9 @@ RequestEncoder<BUFFER>::encodeExecute(unsigned int stmt_id, const T& parameters)
 		MPP_AS_CONST(Iproto::STMT_ID), stmt_id,
 		MPP_AS_CONST(Iproto::SQL_BIND), parameters,
 		MPP_AS_CONST(Iproto::OPTIONS), std::make_tuple())));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -301,9 +301,9 @@ RequestEncoder<BUFFER>::encodePrepare(const std::string& statement)
 	encodeHeader(Iproto::PREPARE);
 	mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
 		MPP_AS_CONST(Iproto::SQL_TEXT), statement)));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -319,9 +319,9 @@ RequestEncoder<BUFFER>::encodeCall(const std::string &func, const T &args)
 	mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
 		MPP_AS_CONST(Iproto::FUNCTION_NAME), func,
 		MPP_AS_CONST(Iproto::TUPLE), mpp::as_arr(args))));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
@@ -342,9 +342,9 @@ RequestEncoder<BUFFER>::encodeAuth(std::string_view user,
 		MPP_AS_CONST(Iproto::USER_NAME), user,
 		MPP_AS_CONST(Iproto::TUPLE),
 		std::make_tuple("chap-sha1", scram_str))));
-	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
 	++request_start;
-	request_start.set(__builtin_bswap32(request_size));
+	request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
 	return request_size + PREHEADER_SIZE;
 }
 
diff --git a/src/Client/ResponseDecoder.hpp b/src/Client/ResponseDecoder.hpp
index 5f5a04abb..0f579287e 100644
--- a/src/Client/ResponseDecoder.hpp
+++ b/src/Client/ResponseDecoder.hpp
@@ -136,7 +136,7 @@ parseGreeting(std::string_view raw, Greeting &greeting) {
 	std::string_view salt_encoded = line2.substr(0, Iproto::GREETING_MAX_SALT_SIZE);
 	char *out = base64::decode(salt_encoded.begin(), salt_encoded.end(),
 				   greeting.salt).second;
-	greeting.salt_size = out - greeting.salt;
+	greeting.salt_size = static_cast<size_t>(out - greeting.salt);
 	assert(greeting.salt_size <= sizeof(greeting.salt));
 	if (greeting.salt_size < Iproto::SCRAMBLE_SIZE)
 		return -1;
diff --git a/src/Client/Stream.hpp b/src/Client/Stream.hpp
index e3b1d5100..6df56b20a 100644
--- a/src/Client/Stream.hpp
+++ b/src/Client/Stream.hpp
@@ -211,7 +211,7 @@ Stream::set_status(uint32_t st)
 	else
 		status |= st;
 	assert(has_status(SS_ESTABLISHED) ||
-	       (status & ~SS_READINESS_STATUS) == 0);
+	       (status & ~unsigned(SS_READINESS_STATUS)) == 0);
 	assert(!(has_status(SS_NEED_READ_EVENT_FOR_READ) &&
 		 has_status(SS_NEED_WRITE_EVENT_FOR_READ)));
 	assert(!(has_status(SS_NEED_READ_EVENT_FOR_WRITE) &&
diff --git a/src/Client/UnixPlainStream.hpp b/src/Client/UnixPlainStream.hpp
index 25d8ccb8d..3a4165bfa 100644
--- a/src/Client/UnixPlainStream.hpp
+++ b/src/Client/UnixPlainStream.hpp
@@ -86,7 +86,7 @@ create_msghdr(struct iovec *iov, size_t iov_count)
 {
 	struct msghdr msg{};
 	msg.msg_iov = iov;
-	msg.msg_iovlen = iov_count;
+	msg.msg_iovlen = static_cast<int>(iov_count);
 	return msg;
 }
 } // namespace internal
diff --git a/src/Client/UnixSSLStream.hpp b/src/Client/UnixSSLStream.hpp
index 8cad99bdd..850e6c24c 100644
--- a/src/Client/UnixSSLStream.hpp
+++ b/src/Client/UnixSSLStream.hpp
@@ -401,7 +401,7 @@ ssize_t UnixSSLStream::send(struct iovec *iov, size_t iov_count)
 	size_t sent;
 	int ret = SSL_write_ex(ssl, iov->iov_base, iov->iov_len, &sent);
 	if (ret == 1)
-		return sent;
+		return static_cast<ssize_t>(sent);
 
 	int err = SSL_get_error(ssl, ret);
 	switch (err) {
@@ -444,7 +444,7 @@ ssize_t UnixSSLStream::recv(struct iovec *iov, size_t iov_count)
 	size_t rcvd;
 	int ret = SSL_read_ex(ssl, iov->iov_base, iov->iov_len, &rcvd);
 	if (ret == 1)
-		return rcvd;
+		return static_cast<ssize_t>(rcvd);
 
 	int err = SSL_get_error(ssl, ret);
 	switch (err) {
diff --git a/src/Client/UnixStream.hpp b/src/Client/UnixStream.hpp
index 3caaca69c..d208cab38 100644
--- a/src/Client/UnixStream.hpp
+++ b/src/Client/UnixStream.hpp
@@ -197,7 +197,8 @@ UnixStream::connect(const ConnectOptions &opts_arg)
 				struct pollfd fds;
 				fds.fd = fd;
 				fds.events = POLLOUT;
-				if (poll(&fds, 1, opts.connect_timeout) == 0) {
+				int timeout = static_cast<int>(opts.connect_timeout);
+				if (poll(&fds, 1, timeout) == 0) {
 					connect_errno = ETIMEDOUT;
 					break;
 				}
diff --git a/src/Utils/Base64.hpp b/src/Utils/Base64.hpp
index 73686f636..1a1f4f90f 100644
--- a/src/Utils/Base64.hpp
+++ b/src/Utils/Base64.hpp
@@ -140,7 +140,8 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
 		if (BASE64_UNLIKELY(first == last))
 			return {first, dest};
 
-		uint8_t c = decmap[static_cast<uint8_t>(*first)];
+		uint8_t c = static_cast<uint8_t>(
+			decmap[static_cast<uint8_t>(*first)]);
 		if (BASE64_UNLIKELY(c >= 64)) // Bad char or '=' here is error.
 			return {first, dest};
 		uint32_t part = c; // 6 bits.
@@ -150,7 +151,7 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
 		if (BASE64_UNLIKELY(next == last)) // Unexpected end.
 			return {first, dest};
 
-		c = decmap[static_cast<uint8_t>(*next)];
+		c = static_cast<uint8_t>(decmap[static_cast<uint8_t>(*next)]);
 		if (BASE64_UNLIKELY(c >= 64)) // Bad char or '=' here is error.
 			return {first, dest};
 
@@ -169,7 +170,7 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
 			return {next, dest};
 		}
 
-		c = decmap[static_cast<uint8_t>(*next)];
+		c = static_cast<uint8_t>(decmap[static_cast<uint8_t>(*next)]);
 		if (BASE64_UNLIKELY(c >= 64)) {
 			if (BASE64_UNLIKELY((part & 0xf) != 0))
 				// Incorrect (non-zero) remainder.
@@ -201,7 +202,7 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
 			return {next, dest};
 		}
 
-		c = decmap[static_cast<uint8_t>(*next)];
+		c = static_cast<uint8_t>(decmap[static_cast<uint8_t>(*next)]);
 		if (BASE64_UNLIKELY(c >= 64)) {
 			if (BASE64_UNLIKELY((part & 0x3) != 0))
 				// Incorrect (non-zero) remainder.
diff --git a/src/Utils/Mempool.hpp b/src/Utils/Mempool.hpp
index f7b3287bf..cf62491a1 100644
--- a/src/Utils/Mempool.hpp
+++ b/src/Utils/Mempool.hpp
@@ -190,7 +190,8 @@ class MempoolInstance : public MempoolStats<ENABLE_STATS> {
 
 			size_t bc =  Stats_t::statBlockCount();
 			size_t total_block_count = sc * (M - 1);
-			size_t prealloc = (m_SlabDataEnd - m_SlabDataBeg) / B;
+			ptrdiff_t data_len = m_SlabDataEnd - m_SlabDataBeg;
+			size_t prealloc = static_cast<size_t>(data_len) / B;
 			size_t expect_free = total_block_count - prealloc - bc;
 			if (calc_free_block_count != expect_free)
 				res |= 2;
diff --git a/src/Utils/ObjHolder.hpp b/src/Utils/ObjHolder.hpp
deleted file mode 100644
index e1b2d2aa9..000000000
--- a/src/Utils/ObjHolder.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-/*
- * Copyright 2010-2020, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-
-namespace tnt {
-
-template <size_t MAX_OBJECT_SIZE>
-struct ObjHolder {
-	void (*destroy_f)(ObjHolder *) = nullptr;
-	char data[MAX_OBJECT_SIZE];
-
-	ObjHolder() = default;
-	ObjHolder(const ObjHolder&) = delete;
-	ObjHolder& operator=(const ObjHolder&) = delete;
-	~ObjHolder() noexcept { destroy(); }
-
-	template <class T, class... ARGS>
-	void create(ARGS&&... args)
-	{
-		static_assert(sizeof(T) <= sizeof(data));
-		T* ptr = new (data) T(std::forward<ARGS>(args)...);
-		assert(ptr == reinterpret_cast<T*>(data)); (void)ptr;
-		if constexpr (std::is_trivially_destructible_v<T>)
-			destroy_f = nullptr;
-		else
-			destroy_f = [](ObjHolder *s) { s->get<T>().~T(); };
-	}
-	void destroy()
-	{
-		if (destroy_f != nullptr)
-			destroy_f(this);
-		destroy_f = nullptr;
-	}
-	template <class T>
-	T &get()
-	{
-		return *reinterpret_cast<T*>(data);
-	}
-};
-
-} // namespace tnt {
diff --git a/src/Utils/Sha1.hpp b/src/Utils/Sha1.hpp
index ca1e7a5af..431121e0a 100644
--- a/src/Utils/Sha1.hpp
+++ b/src/Utils/Sha1.hpp
@@ -79,7 +79,8 @@ Sha1Calc::Sha1Calc()
 template <class T, class...More>
 void Sha1Calc::add(T &&t, More &&...more)
 {
-	SHA1Update(&ctx, std::begin(t), std::size(t));
+	uint32_t size = static_cast<uint32_t>(std::size(t));
+	SHA1Update(&ctx, std::begin(t), size);
 	add(std::forward<More>(more)...);
 }
 
@@ -109,7 +110,7 @@ Sha1_type sha1(T &&...t)
 void sha1_xor(Sha1_type &a, const Sha1_type &b)
 {
 	for (size_t i = 0; i < SHA1_SIZE; i++)
-		a[i] ^= b[i];
+		a[i] = static_cast<Sha1_type::value_type>(a[i] ^ b[i]);
 }
 
 } // namespace tnt
diff --git a/src/Utils/Timer.hpp b/src/Utils/Timer.hpp
index 6396b65c5..eae9aa46d 100644
--- a/src/Utils/Timer.hpp
+++ b/src/Utils/Timer.hpp
@@ -54,7 +54,7 @@ class Timer {
 			return 0;
 		std::chrono::time_point<std::chrono::steady_clock> end =
 			std::chrono::steady_clock::now();
-		return std::chrono::duration_cast<std::chrono::milliseconds>(end - m_Start).count();
+		return static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(end - m_Start).count());
 	}
 private:
 	std::chrono::milliseconds m_Timeout;
diff --git a/src/mpp/Constants.hpp b/src/mpp/Constants.hpp
index 4aed36729..6d7f78a61 100644
--- a/src/mpp/Constants.hpp
+++ b/src/mpp/Constants.hpp
@@ -184,7 +184,7 @@ operator<<(std::ostream& strm, Family t)
 	bool first = true;
 	do {
 		static_assert(sizeof(unsigned) == sizeof(t), "Wrong ctz");
-		unsigned part = __builtin_ctz(base);
+		unsigned part = static_cast<unsigned>(__builtin_ctz(base));
 		base ^= 1u << part;
 		if (first)
 			first = false;
@@ -287,7 +287,7 @@ operator<<(std::ostream& strm, ReadResult_t t)
 	bool first = true;
 	do {
 		static_assert(sizeof(unsigned) == sizeof(t), "Wrong ctz");
-		unsigned part = __builtin_ctz(base);
+		unsigned part = static_cast<unsigned>(__builtin_ctz(base));
 		base ^= 1u << part;
 		if (first)
 			first = false;
diff --git a/src/mpp/Dec.hpp b/src/mpp/Dec.hpp
index 40cfb09b6..932c94f51 100644
--- a/src/mpp/Dec.hpp
+++ b/src/mpp/Dec.hpp
@@ -416,7 +416,7 @@ auto read_value(BUF& buf)
 		assert(tag >= rule_simplex_tag_range_v<RULE>.first);
 		assert(tag <= rule_simplex_tag_range_v<RULE>.last);
 		[[maybe_unused]] typename RULE::simplex_value_t val =
-			tag - RULE::simplex_tag;
+			static_cast<typename RULE::simplex_value_t>(tag - RULE::simplex_tag);
 
 		if constexpr (FAMILY == compact::MP_NIL)
 			return nullptr;
@@ -485,7 +485,7 @@ auto read_item(BUF& buf, ITEM& item)
 	} else if constexpr (tnt::is_optional_v<ITEM> && FAMILY == compact::MP_NIL) {
 		item.reset();
 	} else {
-		item = val;
+		item = static_cast<ITEM>(val);
 	}
 	return val;
 }
@@ -601,8 +601,8 @@ struct JumpsBuilder {
 			jump_common<FAMILY, SUBRULE, PATH, BUF, T...>;
 		if constexpr (SUBRULE == SIMPLEX_SUBRULE) {
 			constexpr auto t = RULE::simplex_tag;
-			constexpr uint8_t f = RULE::simplex_value_range.first;
-			constexpr uint8_t l = RULE::simplex_value_range.last;
+			constexpr uint8_t f = static_cast<uint8_t>(RULE::simplex_value_range.first);
+			constexpr uint8_t l = static_cast<uint8_t>(RULE::simplex_value_range.last);
 			return Jumps<BUF, T...>{j, t + f, t + l};
 		} else {
 			constexpr auto t = RULE::complex_tag;
diff --git a/src/mpp/Enc.hpp b/src/mpp/Enc.hpp
index f0dda3886..03c49ae4a 100644
--- a/src/mpp/Enc.hpp
+++ b/src/mpp/Enc.hpp
@@ -169,7 +169,8 @@ auto getValue([[maybe_unused]] const T& t, [[maybe_unused]] const U& u)
 			return uniLength32(u);
 		} else {
 			static_assert(std::is_standard_layout_v<U>);
-			return std::integral_constant<uint32_t, sizeof(U)>{};
+			constexpr uint32_t value = static_cast<uint32_t>(sizeof(U));
+			return std::integral_constant<uint32_t, value>{};
 		}
 	} else if constexpr (FAMILY == compact::MP_ARR) {
 		return uniSize32(u);
@@ -415,15 +416,15 @@ constexpr auto getTagValSimple([[maybe_unused]] V value)
 		return std::make_pair(tag, enc_val);
 	} else if constexpr(tnt::is_integral_constant_v<V>) {
 		constexpr auto cv = V::value;
-		constexpr size_t soff = find_simplex_offset<RULE>(cv);
+		constexpr size_t soff = static_cast<size_t>(find_simplex_offset<RULE>(cv));
 		if constexpr(soff < RULE::simplex_value_range.count) {
 			constexpr uint8_t ut = RULE::simplex_tag + soff;
-			constexpr int8_t t = static_cast<uint8_t>(ut);
+			constexpr int8_t t = static_cast<int8_t>(ut);
 			return std::make_pair(tnt::CStr<t>{}, Nothing{});
 		} else {
 			constexpr size_t coff = find_complex_offset<RULE>(cv);
 			constexpr uint8_t ut = RULE::complex_tag + coff;
-			constexpr int8_t t = static_cast<uint8_t>(ut);
+			constexpr int8_t t = static_cast<int8_t>(ut);
 			using types = typename RULE::complex_types;
 			using type = std::tuple_element_t<coff, types>;
 			std::integral_constant<type, cv> val;
@@ -432,8 +433,8 @@ constexpr auto getTagValSimple([[maybe_unused]] V value)
 		}
 	} else {
 		static_assert(RULE::has_simplex);
-		size_t soff = find_simplex_offset<RULE>(value);
-		uint8_t t = RULE::simplex_tag + soff;
+		size_t soff = static_cast<size_t>(find_simplex_offset<RULE>(value));
+		uint8_t t = static_cast<uint8_t>(RULE::simplex_tag + soff);
 		return std::make_pair(t, Nothing{});
 	}
 }
@@ -674,9 +675,9 @@ encode(CONT &cont, tnt::CStr<C...> prefix,
 			using types = typename rule_t::complex_types;
 
 			if constexpr(rule_t::has_simplex) {
-				size_t soff = find_simplex_offset<rule_t>(value);
+				size_t soff = static_cast<size_t>(find_simplex_offset<rule_t>(value));
 				if (soff < rule_t::simplex_value_range.count) {
-					uint8_t tag = rule_t::simplex_tag + soff;
+					uint8_t tag = static_cast<uint8_t>(rule_t::simplex_tag + soff);
 					cont.write(prefix);
 					cont.write(tag);
 					return encode(cont, tnt::CStr<>{}, is,
diff --git a/src/mpp/Rules.hpp b/src/mpp/Rules.hpp
index 7bab27977..78d4df4cb 100644
--- a/src/mpp/Rules.hpp
+++ b/src/mpp/Rules.hpp
@@ -104,7 +104,7 @@ struct RuleRange {
 	T last;
 	size_t count;
 	constexpr RuleRange(T first_, T last_) : first(first_), last(last_),
-						 count(last - first + 1) {}
+		count(static_cast<size_t>(last - first + 1)) {}
 };
 
 template <compact::Family FAMILY, class ...TYPE>
@@ -319,18 +319,18 @@ constexpr int find_simplex_offset([[maybe_unused]] E eval)
 			      1 + (1 << RULE::simplex_value_range.last));
 		static_assert(details::exp_range[0] ==
 			      RULE::simplex_value_range.count);
-		return details::exp_range[val];
+		return static_cast<int>(details::exp_range[val]);
 	} else if constexpr (!RULE::is_simplex_signed || !std::is_signed_v<V>) {
 		constexpr std::make_unsigned_t<typename RULE::simplex_value_t>
 		        range_last = RULE::simplex_value_range.last;
 		if (val <= range_last)
-			return val;
+			return static_cast<int>(val);
 		else
 			return RULE::simplex_value_range.count;
 	} else {
 		if (val >= RULE::simplex_value_range.first &&
 		    val <= RULE::simplex_value_range.last)
-			return val;
+			return static_cast<int>(val);
 		else
 			return RULE::simplex_value_range.count;
 	}
diff --git a/test/Base64UnitTest.cpp b/test/Base64UnitTest.cpp
index a3c7e12c7..63e353102 100644
--- a/test/Base64UnitTest.cpp
+++ b/test/Base64UnitTest.cpp
@@ -65,7 +65,8 @@ gen_src_strings()
 		decmap[i] = -1;
 	for (size_t i = 0; i < 2; i++)
 		for (size_t j = 0; j < 64; j++)
-			decmap[static_cast<uint8_t>(alphabets[i][j])] = j;
+			decmap[static_cast<uint8_t>(alphabets[i][j])] =
+				static_cast<char>(j);
 	decmap[size_t('=')] = 64;
 
 	std::cout << "\tconst char *alphabets[2] = {\n";
@@ -77,7 +78,7 @@ gen_src_strings()
 	for (size_t i = 0; i < 16; i++) {
 		std::cout << "\t\t\"";
 		for (size_t j = 0; j < 16; j++) {
-			uint8_t c = decmap[i * 16 + j];
+			uint8_t c = static_cast<uint8_t>(decmap[i * 16 + j]);
 			std::cout << "\\"
 				  << static_cast<char>(('0' + (c >> 6)))
 				  << static_cast<char>(('0' + ((c >> 3) & 0x7)))
@@ -97,8 +98,8 @@ simple_test(const char *orig, size_t orig_size,
 
 	{
 		auto [inp, out] = base64::encode(orig, orig + orig_size, buf);
-		size_t processed_src = inp - orig;
-		size_t processed_dst = out - buf;
+		size_t processed_src = static_cast<size_t>(inp - orig);
+		size_t processed_dst = static_cast<size_t>(out - buf);
 		fail_unless(processed_src == orig_size);
 		fail_unless(processed_dst == base64::enc_size(orig_size));
 		fail_unless(processed_dst == encoded_size);
@@ -107,8 +108,8 @@ simple_test(const char *orig, size_t orig_size,
 
 	{
 		auto [inp, out] = base64::decode(encoded, encoded + encoded_size, buf);
-		size_t processed_src = inp - encoded;
-		size_t processed_dst = out - buf;
+		size_t processed_src = static_cast<size_t>(inp - encoded);
+		size_t processed_dst = static_cast<size_t>(out - buf);
 		fail_unless(processed_src == encoded_size);
 		fail_unless(processed_dst == base64::dec_size(encoded_size) ||
 			    processed_dst + 1 == base64::dec_size(encoded_size) ||
@@ -139,8 +140,8 @@ forth_and_back_test(const char *orig, size_t orig_size)
 	size_t encoded_size;
 	{
 		auto [inp, out] = base64::encode(orig, orig + orig_size, buf);
-		size_t processed_src = inp - orig;
-		encoded_size = out - buf;
+		size_t processed_src = static_cast<size_t>(inp - orig);
+		encoded_size = static_cast<size_t>(out - buf);
 		fail_unless(processed_src == orig_size);
 		fail_unless(encoded_size == base64::enc_size(orig_size));
 	}
@@ -149,8 +150,8 @@ forth_and_back_test(const char *orig, size_t orig_size)
 	size_t decoded_size;
 	{
 		auto [inp, out] = base64::decode(buf, buf + encoded_size, buf2);
-		size_t processed_src = inp - buf;
-		decoded_size = out - buf2;
+		size_t processed_src = static_cast<size_t>(inp - buf);
+		decoded_size = static_cast<size_t>(out - buf2);
 		fail_unless(processed_src == encoded_size);
 		fail_unless(decoded_size == base64::dec_size(encoded_size) ||
 			    decoded_size + 1 == base64::dec_size(encoded_size) ||
@@ -170,9 +171,9 @@ forth_and_back_tests()
 
 	for (size_t k = 0; k < K; k++) {
 		for (size_t i = 0; i < N[k]; i++) {
-			size_t s = 1 + rand() % (M[k] - 1);
+			size_t s = 1 + static_cast<size_t>(rand()) % (M[k] - 1);
 			for (size_t j = 0; j < s; j++)
-				buf[j] = rand();
+				buf[j] = static_cast<char>(rand());
 			forth_and_back_test(buf, s);
 		}
 	}
@@ -186,8 +187,8 @@ check_bad_ending(const char *enc,
 	size_t enc_size = strlen(enc);
 	char res[256];
 	auto [cons_end,prod_end] = base64::decode(enc, enc + enc_size, res);
-	size_t real_cons = cons_end - enc;
-	size_t real_prod = prod_end - res;
+	size_t real_cons = static_cast<size_t>(cons_end - enc);
+	size_t real_prod = static_cast<size_t>(prod_end - res);
 	fail_unless(expected_consumed == real_cons);
 	fail_unless(expected_produced == real_prod);
 	fail_unless(memcmp(res, expected_dec, expected_produced) == 0);
diff --git a/test/BufferUnitTest.cpp b/test/BufferUnitTest.cpp
index 9a63c72da..18fbd3470 100644
--- a/test/BufferUnitTest.cpp
+++ b/test/BufferUnitTest.cpp
@@ -71,7 +71,7 @@ template<size_t N>
 static void
 eraseBuffer(tnt::Buffer<N> &buffer)
 {
-	int IOVEC_MAX = 1024;
+	size_t IOVEC_MAX = 1024;
 	struct iovec vec[IOVEC_MAX];
 	do {
 		size_t vec_size = buffer.getIOV(buffer.begin(), vec, IOVEC_MAX);
@@ -89,7 +89,7 @@ static void
 dumpBuffer(tnt::Buffer<N> &buffer, std::string &output)
 {
 	size_t vec_len = 0;
-	int IOVEC_MAX = 1024;
+	size_t IOVEC_MAX = 1024;
 	size_t block_cnt = 0;
 	struct iovec vec[IOVEC_MAX];
 	for (auto itr = buffer.begin(); itr != buffer.end(); itr += vec_len) {
@@ -253,10 +253,10 @@ buffer_add_read()
 		case 3:
 			buf.write(static_cast<uint64_t>(r)); break;
 		default: {
-			size_t sz = r % 13 + 1;
+			size_t sz = static_cast<size_t>(r % 13 + 1);
 			char data[16];
 			for (size_t j = 0; j < sz; j++)
-				data[j] = rand();
+				data[j] = static_cast<char>(rand());
 			buf.write({data, sz});
 		}
 		}
@@ -284,13 +284,13 @@ buffer_add_read()
 				    static_cast<uint64_t>(r));
 			break;
 		default: {
-			size_t sz = r % 13 + 1;
+			size_t sz = static_cast<size_t>(r % 13 + 1);
 			char data1[16];
 			for (size_t j = 0; j < sz; j++)
-				data1[j] = rand();
+				data1[j] = static_cast<char>(rand());
 			fail_unless(itr1.startsWith({data1, sz}));
-			unsigned char last_char = data1[sz - 1];
-			data1[sz - 1] = last_char + 1;
+			char last_char = data1[sz - 1];
+			data1[sz - 1] = static_cast<char>(last_char + 1);
 			fail_if(itr1.startsWith({data1, sz}));
 			data1[sz - 1] = last_char;
 			char data2[16];
@@ -323,10 +323,10 @@ buffer_add_read()
 				    static_cast<uint64_t>(r));
 			break;
 		default: {
-			size_t sz = r % 13 + 1;
+			size_t sz = static_cast<size_t>(r % 13 + 1);
 			char data1[16];
 			for (size_t j = 0; j < sz; j++)
-				data1[j] = rand();
+				data1[j] = static_cast<char>(rand());
 			char data2[16];
 			itr2.read({data2, sz});
 			fail_unless(memcmp(data1, data2, sz) == 0);
@@ -570,12 +570,12 @@ buffer_out()
 	buf.write(__builtin_bswap16(512)); // space_id = 512
 	buf.write(0x20); // IPROTO_KEY
 	buf.write(0x90); // empty array key
-	size_t total = buf.end() - save;
+	unsigned total = static_cast<unsigned>(buf.end() - save);
 	save.set(__builtin_bswap32(total)); // set calculated size
 	fail_if(buf.debugSelfCheck());
 	save.unlink();
 	do {
-		int IOVEC_MAX = 1024;
+		size_t IOVEC_MAX = 1024;
 		struct iovec vec[IOVEC_MAX];
 		size_t vec_size = buf.getIOV(buf.begin(), vec, IOVEC_MAX);
 		buf.dropFront(vec_size);
diff --git a/test/ClientTest.cpp b/test/ClientTest.cpp
index 38dd022cc..bc531388a 100644
--- a/test/ClientTest.cpp
+++ b/test/ClientTest.cpp
@@ -36,8 +36,8 @@
 #include "../src/Client/Connector.hpp"
 
 const char *localhost = "127.0.0.1";
-int port = 3301;
-int dummy_server_port = 3302;
+unsigned port = 3301;
+unsigned dummy_server_port = 3302;
 const char *unixsocket = "./tnt.sock";
 int WAIT_TIMEOUT = 1000; //milliseconds
 
@@ -160,7 +160,7 @@ trivial(Connector<BUFFER, NetProvider> &client)
 	rc = test_connect(client, conn, "101.101.101", port);
 	fail_unless(rc != 0);
 	TEST_CASE("Wrong port");
-	rc = test_connect(client, conn, localhost, -666);
+	rc = test_connect(client, conn, localhost, static_cast<uint>(-666));
 	fail_unless(rc != 0);
 	TEST_CASE("Connect timeout");
 	rc = test_connect(client, conn, "8.8.8.8", port);
@@ -290,7 +290,7 @@ single_conn_error(Connector<BUFFER, NetProvider> &client)
 	int rc = test_connect(client, conn, localhost, port);
 	fail_unless(rc == 0);
 	/* Fake space id. */
-	uint32_t space_id = -111;
+	uint32_t space_id = static_cast<uint32_t>(-111);
 	std::tuple data = std::make_tuple(666);
 	rid_t f1 = conn.space[space_id].replace(data);
 	client.wait(conn, f1, WAIT_TIMEOUT);
diff --git a/test/EncDecTest.cpp b/test/EncDecTest.cpp
index defc45831..6f5d69af3 100644
--- a/test/EncDecTest.cpp
+++ b/test/EncDecTest.cpp
@@ -75,13 +75,14 @@ test_bswap()
 		static_assert(std::is_integral_v<decltype(x)>);
 		static_assert(std::is_unsigned_v<decltype(x)>);
 		auto res = x;
+		using T = decltype(x);
 		if constexpr (sizeof(x) == 1) {
 			return res;
 		} else {
 			for (size_t i = 0; i < sizeof(x); i++) {
-				res <<= 8;
+				res = static_cast<T>(res << 8);
 				res |= x & 0xFF;
-				x >>= 8;
+				x = static_cast<T>(x >> 8);
 			}
 		}
 		return res;
@@ -132,7 +133,7 @@ test_bswap()
 		fail_unless(bswap_naive((under_t) x) == mpp::bswap(x));
 	}
 	{
-		float x = 3.1415927;
+		float x = 3.1415927f;
 		using under_t = uint32_t;
 		static_assert(std::is_same_v<under_t, decltype(mpp::bswap(x))>);
 		under_t y;
@@ -264,8 +265,8 @@ test_basic()
 	mpp::encode(buf, add_map);
 
 	for (auto itr = buf.begin(); itr != buf.end(); ++itr) {
-		char c = itr.get<uint8_t>();
-		uint8_t u = c;
+		uint8_t u = itr.get<uint8_t>();
+		char c = static_cast<char>(u);
 		const char *h = "0123456789ABCDEF";
 		if (c >= 'a' && c <= 'z')
 			std::cout << c;
@@ -768,7 +769,7 @@ struct Triplet {
 	int b = 0;
 	int c = 0;
 
-	void gen(size_t i)
+	void gen(int i)
 	{
 		a = 3 * i + 1;
 		b = 3 * i + 100500;
@@ -797,9 +798,9 @@ struct Error {
 	int code = 0;
 	std::string descr;
 
-	void gen(size_t i)
+	void gen(int i)
 	{
-		code = i + 1;
+		code = static_cast<int>(i + 1);
 		descr = std::to_string(code);
 	}
 
@@ -830,10 +831,10 @@ struct Body {
 		num.gen();
 		triplets.resize(2);
 		for (size_t i = 0; i < triplets.size(); i++)
-			triplets[i].gen(i);
+			triplets[i].gen(static_cast<int>(i));
 		errors.resize(3);
 		for (size_t i = 0; i < errors.size(); i++)
-			errors[i].gen(i);
+			errors[i].gen(static_cast<int>(i));
 	}
 
 	bool operator==(const Body& that) const
@@ -871,8 +872,8 @@ test_object_codec()
 	mpp::encode(buf, std::forward_as_tuple(wr));
 
 	for (auto itr = buf.begin(); itr != buf.end(); ++itr) {
-		char c = itr.get<uint8_t>();
-		uint8_t u = c;
+		uint8_t u = itr.get<uint8_t>();
+		char c = static_cast<char>(u);
 		const char *h = "0123456789ABCDEF";
 		if (c >= 'a' && c <= 'z')
 			std::cout << c;
@@ -923,7 +924,7 @@ test_optional()
 	buf.flush();
 
 	TEST_CASE("containers with numbers");
-	int null_idx = 4;
+	size_t null_idx = 4;
 	mpp::encode(buf, std::make_optional(mpp::as_arr(
 		std::forward_as_tuple(0, std::make_optional(1), 2, 3, std::optional<int>(), 5)
 	)));
@@ -937,20 +938,21 @@ test_optional()
 	ok = mpp::decode(run, opt_num_arr);
 	fail_unless(ok);
 	fail_unless(opt_num_arr.size() == 6);
-	for (int i = 0; i < 6; i++) {
+	for (size_t i = 0; i < 6; i++) {
 		if (i == null_idx) {
 			fail_unless(!opt_num_arr[i].has_value());
 			continue;
 		}
+		int val = static_cast<int>(i);
 		fail_unless(opt_num_arr[i].has_value());
-		fail_unless(opt_num_arr[i].value() == i);
+		fail_unless(opt_num_arr[i].value() == val);
 	}
 
 	run = buf.begin<true>();
 	ok = mpp::decode(run, opt_num_set);
 	fail_unless(ok);
 	fail_unless(opt_num_set.size() == 6);
-	for (int i = 0; i < 6; i++) {
+	for (size_t i = 0; i < 6; i++) {
 		if (i == null_idx) {
 			fail_unless(opt_num_set.count(i) == 0);
 			fail_unless(opt_num_set.count(std::nullopt) == 1);
@@ -964,13 +966,14 @@ test_optional()
 	fail_unless(ok);
 	fail_unless(opt_num_opt_arr.has_value());
 	fail_unless(opt_num_opt_arr->size() == 6);
-	for (int i = 0; i < 6; i++) {
+	for (size_t i = 0; i < 6; i++) {
 		if (i == null_idx) {
 			fail_unless(!opt_num_opt_arr.value()[i].has_value());
 			continue;
 		}
+		int val = static_cast<int>(i);
 		fail_unless(opt_num_opt_arr.value()[i].has_value());
-		fail_unless(opt_num_opt_arr.value()[i].value() == i);
+		fail_unless(opt_num_opt_arr.value()[i].value() == val);
 	}
 	ok = mpp::decode(run, opt_num_opt_arr);
 	fail_unless(ok);
@@ -981,7 +984,7 @@ test_optional()
 	fail_unless(ok);
 	fail_unless(opt_num_opt_set.has_value());
 	fail_unless(opt_num_opt_set->size() == 6);
-	for (int i = 0; i < 6; i++) {
+	for (size_t i = 0; i < 6; i++) {
 		if (i == null_idx) {
 			fail_unless(opt_num_opt_set->count(i) == 0);
 			fail_unless(opt_num_opt_set->count(std::nullopt) == 1);
@@ -1044,7 +1047,7 @@ test_optional()
 	ok = mpp::decode(run, opt_body_arr);
 	fail_unless(ok);
 	fail_unless(opt_body_arr.size() == 3);
-	for (int i = 0; i < 3; i++) {
+	for (size_t i = 0; i < 3; i++) {
 		if (i == null_idx) {
 			fail_unless(!opt_body_arr[i].has_value());
 			continue;
@@ -1058,7 +1061,7 @@ test_optional()
 	fail_unless(ok);
 	fail_unless(opt_body_set.size() == 3);
 	fail_unless(opt_body_set.count(std::nullopt) == 1);
-	for (int i = 0; i < 3; i++) {
+	for (size_t i = 0; i < 3; i++) {
 		if (i == null_idx) {
 			fail_unless(opt_body_set.count(wrs[i]) == 0);
 			continue;
@@ -1071,7 +1074,7 @@ test_optional()
 	fail_unless(ok);
 	fail_unless(opt_body_opt_arr.has_value());
 	fail_unless(opt_body_opt_arr->size() == 3);
-	for (int i = 0; i < 3; i++) {
+	for (size_t i = 0; i < 3; i++) {
 		if (i == null_idx) {
 			fail_unless(!opt_body_opt_arr.value()[i].has_value());
 			continue;
@@ -1089,7 +1092,7 @@ test_optional()
 	fail_unless(opt_body_opt_set.has_value());
 	fail_unless(opt_body_opt_set->size() == 3);
 	fail_unless(opt_body_opt_set->count(std::nullopt) == 1);
-	for (int i = 0; i < 3; i++) {
+	for (size_t i = 0; i < 3; i++) {
 		if (i == null_idx) {
 			fail_unless(opt_body_opt_set->count(wrs[i]) == 0);
 			continue;
diff --git a/test/ListUnitTest.cpp b/test/ListUnitTest.cpp
index 4b5c28540..983d15fdb 100644
--- a/test/ListUnitTest.cpp
+++ b/test/ListUnitTest.cpp
@@ -1161,7 +1161,7 @@ void test_multilinik_round()
 	auto create_add_near = [&]() {
 		if (objects.empty())
 			return;
-		MultilistObject& near = objects[rand() % objects.size()];
+		MultilistObject& near = objects[static_cast<size_t>(rand()) % objects.size()];
 		int id = next_id++;
 		int r = rand();
 		bool red_before = 0 != (r & 1);
@@ -1178,7 +1178,7 @@ void test_multilinik_round()
 	auto insert_to_list = [&]() {
 		if (objects.empty())
 			return;
-		MultilistObject& obj = objects[rand() % objects.size()];
+		MultilistObject& obj = objects[static_cast<size_t>(rand()) % objects.size()];
 		int color = rand() % 3;
 		bool to_back = 0 == (rand() & 1);
 		if (color == 0) {
@@ -1199,8 +1199,8 @@ void test_multilinik_round()
 	auto insert_to_near = [&]() {
 		if (objects.size() < 2)
 			return;
-		int r1 = rand() % objects.size(), r2;
-		do r2 = rand() % objects.size(); while (r1 == r2);
+		size_t r1 = static_cast<size_t>(rand()) % objects.size(), r2;
+		do r2 = static_cast<size_t>(rand()) % objects.size(); while (r1 == r2);
 		MultilistObject& obj = objects[r1];
 		MultilistObject& near = objects[r2];
 		int color = rand() % 3;
@@ -1226,7 +1226,7 @@ void test_multilinik_round()
 	auto remove = [&]() {
 		if (objects.empty())
 			return;
-		MultilistObject& victim = objects[rand() % objects.size()];
+		MultilistObject& victim = objects[static_cast<size_t>(rand()) % objects.size()];
 		int color = rand() % 3;
 		if (color == 0) {
 			victim.remove<in_red>();
diff --git a/test/MempoolUnitTest.cpp b/test/MempoolUnitTest.cpp
index 95a73ec90..d171507dd 100644
--- a/test/MempoolUnitTest.cpp
+++ b/test/MempoolUnitTest.cpp
@@ -42,13 +42,13 @@ struct Allocation {
 		static size_t inc_id = 0;
 		ptr = alloc_ptr;
 		id = ++inc_id;
-		char v = id;
+		char v = static_cast<char>(id);
 		for (size_t i = 0; i < S; i++)
 			ptr[i] = v;
 	}
 	bool is_valid() const
 	{
-		char v = id;
+		char v = static_cast<char>(id);
 		for (size_t i = 0; i < S; i++)
 			if (ptr[i] != v)
 				return false;
@@ -140,7 +140,7 @@ test_instance()
 
 	for (size_t i = 0; i < 2 * EXPECT_BLOCKS_IN_SLAB; i++) {
 		for (size_t j = 0; j < i; j++) {
-			size_t k = rand() % all.count;
+			size_t k = static_cast<size_t>(rand()) % all.count;
 			fail_unless(all[k].is_valid());
 			mp.deallocate(all[k].ptr);
 			all.del(k);
diff --git a/test/RulesUnitTest.cpp b/test/RulesUnitTest.cpp
index 3c0d2aded..4975996e9 100644
--- a/test/RulesUnitTest.cpp
+++ b/test/RulesUnitTest.cpp
@@ -301,7 +301,7 @@ void collectByType(FullInfo& infos)
 				set_info += std::to_string(range.last);
 			}
 		}
-		for (uint8_t j = range.first; (j - 1) != range.last; j++) {
+		for (uint8_t j = static_cast<uint8_t>(range.first); (j - 1) != range.last; j++) {
 			auto& info = infos[(uint8_t)(j + tag)];
 			fail_unless(info.empty());
 			info = set_info;
diff --git a/test/TraitsUnitTest.cpp b/test/TraitsUnitTest.cpp
index f8179144b..5b43fa420 100644
--- a/test/TraitsUnitTest.cpp
+++ b/test/TraitsUnitTest.cpp
@@ -486,7 +486,7 @@ test_universal_access()
 
 	fail_unless(tnt::get<0>(stdarr) == 4);
 	fail_unless(tnt::get<1>(stdarr) == 5);
-	tnt::get<1>(stdarr) += 5;
+	tnt::get<1>(stdarr) = static_cast<short>(tnt::get<1>(stdarr) + 5);
 	fail_unless(tnt::get<1>(stdarr) == 10);
 
 	TupleClass tc;
diff --git a/test/Utils/System.hpp b/test/Utils/System.hpp
index 43e2405e4..8b83e997b 100644
--- a/test/Utils/System.hpp
+++ b/test/Utils/System.hpp
@@ -198,7 +198,7 @@ genSSLCert() {
  * `localhost:dummy_server_port`, reads 1 byte and exits.
  */
 int
-launchDummyServer(const char *addr, int port)
+launchDummyServer(const char *addr, unsigned port)
 {
 	pid_t ppid_before_fork = ::getpid();
 	pid_t pid = ::fork();
@@ -232,7 +232,7 @@ launchDummyServer(const char *addr, int port)
 
 	struct sockaddr_in sock_address{};
 	sock_address.sin_family = AF_INET;
-	sock_address.sin_port = htons(port);
+	sock_address.sin_port = htons(static_cast<uint16_t>(port));
 	if (::inet_aton(addr, &sock_address.sin_addr) != 1) {
 		::perror("inet_aton failed");
 		::exit(EXIT_FAILURE);

From 979de54d74c072d565ac16f21122fa12033c106e Mon Sep 17 00:00:00 2001
From: Andrey Saranchin <Andrey22102001@gmail.com>
Date: Wed, 10 Jan 2024 22:12:02 +0300
Subject: [PATCH 3/4] build: support -Wshadow

Since libev and sha1 do not suite very strict GCC shadowing rules,
the commit does not enable shadowing warning for these third-party
libraries.
---
 CMakeLists.txt                  |  2 +-
 examples/Simple.cpp             |  4 ++--
 examples/Sql.cpp                |  3 +--
 src/Client/Connection.hpp       |  4 ++--
 src/Client/LibevNetProvider.hpp |  8 +++++++
 src/Client/UnixPlainStream.hpp  |  6 ++---
 src/Utils/Sha1.hpp              |  3 +++
 src/mpp/Dec.hpp                 |  8 +++----
 test/BufferPerfTest.cpp         |  4 ++--
 test/BufferUnitTest.cpp         |  4 ++--
 test/ClientTest.cpp             | 42 ++++++++++++++++-----------------
 test/ListUnitTest.cpp           |  2 +-
 test/Utils/Out.hpp              |  4 ++--
 13 files changed, 52 insertions(+), 42 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 65009073c..2ad3b926d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,7 +11,7 @@ FIND_PACKAGE (benchmark QUIET)
 
 SET(CMAKE_CXX_STANDARD 17)
 SET(CMAKE_C_STANDARD 11)
-ADD_COMPILE_OPTIONS(-Wall -Wextra -Werror)
+ADD_COMPILE_OPTIONS(-Wall -Wextra -Werror -Wshadow)
 
 ADD_LIBRARY(tntcxx INTERFACE)
 ADD_LIBRARY(tntcxx::tntcxx ALIAS tntcxx)
diff --git a/examples/Simple.cpp b/examples/Simple.cpp
index 7abb0dff8..22412afe7 100644
--- a/examples/Simple.cpp
+++ b/examples/Simple.cpp
@@ -155,8 +155,8 @@ main()
 	uint32_t limit = 1;
 	uint32_t offset = 0;
 	IteratorType iter = IteratorType::EQ;
-	auto i = conn.space[space_id].index[index_id];
-	rid_t select = i.select(std::make_tuple(pk_value), limit, offset, iter);
+	auto index = conn.space[space_id].index[index_id];
+	rid_t select = index.select(std::make_tuple(pk_value), limit, offset, iter);
 	//doclabel09-2
 	/*
 	 * Now let's send our requests to the server. There are two options
diff --git a/examples/Sql.cpp b/examples/Sql.cpp
index 0c37d653f..1a482247c 100644
--- a/examples/Sql.cpp
+++ b/examples/Sql.cpp
@@ -226,8 +226,7 @@ main()
 	client.waitAll(conn, prepared_select_futures);
 	for (size_t i = 0; i < prepared_select_futures.size(); ++i) {
 		assert(conn.futureIsReady(prepared_select_futures[i]));
-		Response<Buf_t> response =
-			conn.getResponse(prepared_select_futures[i]);
+		response = conn.getResponse(prepared_select_futures[i]);
 		printResponse<Buf_t>(response);
 	}
 
diff --git a/src/Client/Connection.hpp b/src/Client/Connection.hpp
index 79ddc56cd..01f0c68fc 100644
--- a/src/Client/Connection.hpp
+++ b/src/Client/Connection.hpp
@@ -46,8 +46,8 @@ static constexpr ssize_t CONN_READAHEAD = 64 * 1024;
 static constexpr size_t IOVEC_MAX_SIZE = 32;
 
 struct ConnectionError {
-	ConnectionError(const std::string &msg, int errno_ = 0) :
-		msg(msg), saved_errno(errno_)
+	ConnectionError(const std::string &errmsg, int errno_ = 0) :
+		msg(errmsg), saved_errno(errno_)
 	{
 	}
 
diff --git a/src/Client/LibevNetProvider.hpp b/src/Client/LibevNetProvider.hpp
index e9a2f590f..4a178fa27 100644
--- a/src/Client/LibevNetProvider.hpp
+++ b/src/Client/LibevNetProvider.hpp
@@ -42,7 +42,15 @@
 #include <string_view>
 
 #include "Connection.hpp"
+
+/**
+ * Disable -Wshadow for libev because ev_loop function shadows
+ * declaration of struct ev_loop constructor.
+ */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow" 
 #include "ev.h"
+#pragma GCC diagnostic pop
 
 template<class BUFFER, class Stream>
 class Connector;
diff --git a/src/Client/UnixPlainStream.hpp b/src/Client/UnixPlainStream.hpp
index 3a4165bfa..624256fcd 100644
--- a/src/Client/UnixPlainStream.hpp
+++ b/src/Client/UnixPlainStream.hpp
@@ -72,12 +72,12 @@ class UnixPlainStream : public UnixStream {
 /////////////////////////////////////////////////////////////////////
 
 int
-UnixPlainStream::connect(const ConnectOptions &opts)
+UnixPlainStream::connect(const ConnectOptions &opts_arg)
 {
-	if (opts.transport != STREAM_PLAIN)
+	if (opts_arg.transport != STREAM_PLAIN)
 		US_DIE("Non-plain socket are unsupported in this build."
 		       "Consider enabling it with -DTNTCXX_ENABLE_TLS.");
-	return UnixStream::connect(opts);
+	return UnixStream::connect(opts_arg);
 }
 
 namespace internal {
diff --git a/src/Utils/Sha1.hpp b/src/Utils/Sha1.hpp
index 431121e0a..8290f7d8d 100644
--- a/src/Utils/Sha1.hpp
+++ b/src/Utils/Sha1.hpp
@@ -33,7 +33,10 @@
 #include <array>
 #include <utility>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
 #include "../third_party/sha1.hpp"
+#pragma GCC diagnostic pop
 
 namespace tnt {
 
diff --git a/src/mpp/Dec.hpp b/src/mpp/Dec.hpp
index 932c94f51..40f7c6ad9 100644
--- a/src/mpp/Dec.hpp
+++ b/src/mpp/Dec.hpp
@@ -547,13 +547,13 @@ struct Jumps {
 	/** Override given tag with special jump. */
 	template <size_t... I>
 	static constexpr data_t
-	build_inject(data_t orig, uint8_t tag, jump_t inject, tnt::iseq<I...>)
+	build_inject(data_t orig, uint8_t tag, jump_t jump, tnt::iseq<I...>)
 	{
-		return {(I != tag ? orig[I] : inject)...};
+		return {(I != tag ? orig[I] : jump)...};
 	}
 
-	constexpr Jumps(Jumps a, uint8_t tag, jump_t inject)
-		: data(build_inject(a.data, tag, inject, is256))
+	constexpr Jumps(Jumps a, uint8_t tag, jump_t jump)
+		: data(build_inject(a.data, tag, jump, is256))
 	{
 	}
 
diff --git a/test/BufferPerfTest.cpp b/test/BufferPerfTest.cpp
index 5d4aca917..49ea5acb3 100644
--- a/test/BufferPerfTest.cpp
+++ b/test/BufferPerfTest.cpp
@@ -56,10 +56,10 @@ struct StaticBuffer {
 
 template <size_t... I, class... T>
 void
-gen_helper(std::index_sequence<I...>, std::tuple<T...>& t)
+gen_helper(std::index_sequence<I...>, std::tuple<T...>& ts)
 {
 	auto set = [](auto& t) { t = rand(); };
-	(set(std::get<I>(t)), ...);
+	(set(std::get<I>(ts)), ...);
 }
 
 template <class... T>
diff --git a/test/BufferUnitTest.cpp b/test/BufferUnitTest.cpp
index 18fbd3470..c1dfd6640 100644
--- a/test/BufferUnitTest.cpp
+++ b/test/BufferUnitTest.cpp
@@ -541,8 +541,8 @@ buffer_release()
 	 * should remain unchanged.
 	 */
 	int i = 0;
-	for (auto tmp = buf.begin(); tmp < mid_itr; ++tmp) {
-		tmp.get(res);
+	for (auto tmp_it = buf.begin(); tmp_it < mid_itr; ++tmp_it) {
+		tmp_it.get(res);
 		fail_unless(res == char_samples[i++ % SAMPLES_CNT]);
 	}
 }
diff --git a/test/ClientTest.cpp b/test/ClientTest.cpp
index bc531388a..b3b9ff428 100644
--- a/test/ClientTest.cpp
+++ b/test/ClientTest.cpp
@@ -36,7 +36,7 @@
 #include "../src/Client/Connector.hpp"
 
 const char *localhost = "127.0.0.1";
-unsigned port = 3301;
+unsigned tarantool_port = 3301;
 unsigned dummy_server_port = 3302;
 const char *unixsocket = "./tnt.sock";
 int WAIT_TIMEOUT = 1000; //milliseconds
@@ -154,16 +154,16 @@ trivial(Connector<BUFFER, NetProvider> &client)
 	fail_unless(rc != 0);
 	/* Connect to the wrong address. */
 	TEST_CASE("Bad address");
-	rc = test_connect(client, conn, "asdasd", port);
+	rc = test_connect(client, conn, "asdasd", tarantool_port);
 	fail_unless(rc != 0);
 	TEST_CASE("Unreachable address");
-	rc = test_connect(client, conn, "101.101.101", port);
+	rc = test_connect(client, conn, "101.101.101", tarantool_port);
 	fail_unless(rc != 0);
 	TEST_CASE("Wrong port");
 	rc = test_connect(client, conn, localhost, static_cast<uint>(-666));
 	fail_unless(rc != 0);
 	TEST_CASE("Connect timeout");
-	rc = test_connect(client, conn, "8.8.8.8", port);
+	rc = test_connect(client, conn, "8.8.8.8", tarantool_port);
 	fail_unless(rc != 0);
 }
 
@@ -174,7 +174,7 @@ single_conn_ping(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	rid_t f = conn.ping();
 	fail_unless(!conn.futureIsReady(f));
@@ -228,13 +228,13 @@ auto_close(Connector<BUFFER, NetProvider> &client)
 	{
 		TEST_CASE("Without requests");
 		Connection<Buf_t, NetProvider> conn(client);
-		int rc = test_connect(client, conn, localhost, port);
+		int rc = test_connect(client, conn, localhost, tarantool_port);
 		fail_unless(rc == 0);
 	}
 	{
 		TEST_CASE("With requests");
 		Connection<Buf_t, NetProvider> conn(client);
-		int rc = test_connect(client, conn, localhost, port);
+		int rc = test_connect(client, conn, localhost, tarantool_port);
 		fail_unless(rc == 0);
 
 		rid_t f = conn.ping();
@@ -255,18 +255,18 @@ many_conn_ping(Connector<BUFFER, NetProvider> &client)
 	Connection<Buf_t, NetProvider> conn1(client);
 	Connection<Buf_t, NetProvider> conn2(client);
 	Connection<Buf_t, NetProvider> conn3(client);
-	int rc = test_connect(client, conn1, localhost, port);
+	int rc = test_connect(client, conn1, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	/* Try to connect to the same port */
-	rc = test_connect(client, conn2, localhost, port);
+	rc = test_connect(client, conn2, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	/*
 	 * Try to re-connect to another address whithout closing
 	 * current connection.
 	 */
-	//rc = test_connect(client, conn2, localhost, port + 2);
+	//rc = test_connect(client, conn2, localhost, tarantool_port + 2);
 	//fail_unless(rc != 0);
-	rc = test_connect(client, conn3, localhost, port);
+	rc = test_connect(client, conn3, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	rid_t f1 = conn1.ping();
 	rid_t f2 = conn2.ping();
@@ -287,7 +287,7 @@ single_conn_error(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	/* Fake space id. */
 	uint32_t space_id = static_cast<uint32_t>(-111);
@@ -324,7 +324,7 @@ single_conn_replace(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	uint32_t space_id = 512;
 	std::tuple data = std::make_tuple(666, "111", 1.01);
@@ -358,7 +358,7 @@ single_conn_insert(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	TEST_CASE("Successful inserts");
 	uint32_t space_id = 512;
@@ -402,7 +402,7 @@ single_conn_update(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	TEST_CASE("Successful update");
 	uint32_t space_id = 512;
@@ -437,7 +437,7 @@ single_conn_delete(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	TEST_CASE("Successful deletes");
 	uint32_t space_id = 512;
@@ -481,7 +481,7 @@ single_conn_upsert(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	TEST_CASE("upsert-insert");
 	uint32_t space_id = 512;
@@ -512,7 +512,7 @@ single_conn_select(Connector<BUFFER, NetProvider> &client)
 {
 	TEST_INIT(0);
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 	uint32_t space_id = 512;
 	uint32_t index_id = 0;
@@ -575,7 +575,7 @@ single_conn_call(Connector<BUFFER, NetProvider> &client)
 	const static char *return_map     = "remote_map";
 
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 
 	TEST_CASE("call remote_replace");
@@ -746,7 +746,7 @@ single_conn_sql(Connector<BUFFER, NetProvider> &client)
 	using Body_t = Body<BUFFER>;
 
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port);
+	int rc = test_connect(client, conn, localhost, tarantool_port);
 	fail_unless(rc == 0);
 
 	TEST_CASE("CREATE TABLE");
@@ -990,7 +990,7 @@ test_auth(Connector<BUFFER, NetProvider> &client)
 	const char *passwd  = "megapassword";
 
 	Connection<Buf_t, NetProvider> conn(client);
-	int rc = test_connect(client, conn, localhost, port, user, passwd);
+	int rc = test_connect(client, conn, localhost, tarantool_port, user, passwd);
 	fail_unless(rc == 0);
 
 	uint32_t space_id = 513;
diff --git a/test/ListUnitTest.cpp b/test/ListUnitTest.cpp
index 983d15fdb..275ce0704 100644
--- a/test/ListUnitTest.cpp
+++ b/test/ListUnitTest.cpp
@@ -246,7 +246,7 @@ void check(const ObjectList& list, std::vector<int> arr,
 
 	if (failed) {
 		std::cerr << "Check failed: list {";
-		bool first = true;
+		first = true;
 		for (const Object& sObj : list) {
 			if (!first)
 				std::cerr << ", " << sObj.m_Data;
diff --git a/test/Utils/Out.hpp b/test/Utils/Out.hpp
index a3bb8547d..62b0741f0 100644
--- a/test/Utils/Out.hpp
+++ b/test/Utils/Out.hpp
@@ -11,7 +11,7 @@
 
 namespace out_internal {
 template <class... T>
-void out(std::string_view names, T&&... t)
+void out(std::string_view names, T&&... ts)
 {
 	auto helper = [&names](auto&& t) {
 		size_t pos = names.find(',');
@@ -23,7 +23,7 @@ void out(std::string_view names, T&&... t)
 			names = names.substr(pos + 1);
 		}
 	};
-	(..., helper(std::forward<T>(t)));
+	(..., helper(std::forward<T>(ts)));
 	std::cout << std::endl;
 }
 } // namespace out_internal {

From 61912780161125ec0195a1317000681bdf8cd1ff Mon Sep 17 00:00:00 2001
From: Andrey Saranchin <Andrey22102001@gmail.com>
Date: Thu, 11 Jan 2024 17:59:03 +0300
Subject: [PATCH 4/4] build: support cast-align and unused warnings

Our codebase already suits these rules - we need only to enable them.
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2ad3b926d..1ac73ee05 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,7 +11,7 @@ FIND_PACKAGE (benchmark QUIET)
 
 SET(CMAKE_CXX_STANDARD 17)
 SET(CMAKE_C_STANDARD 11)
-ADD_COMPILE_OPTIONS(-Wall -Wextra -Werror -Wshadow)
+ADD_COMPILE_OPTIONS(-Wall -Wextra -Werror -Wshadow -Wcast-align -Wunused)
 
 ADD_LIBRARY(tntcxx INTERFACE)
 ADD_LIBRARY(tntcxx::tntcxx ALIAS tntcxx)