Extended warnings

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 -Wcast-align -Wunused)
 
 ADD_LIBRARY(tntcxx INTERFACE)
 ADD_LIBRARY(tntcxx::tntcxx ALIAS tntcxx)
@@ -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()
 

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

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);
 	}
 

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);

src/Client/Connection.hpp

@@ -42,12 +42,12 @@
 /** 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 {
-	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_)
 	{
 	}
 
@@ -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,16 +549,17 @@ 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);
 		return DECODE_NEEDMORE;
 	}
 	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];
 	}

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;
@@ -129,7 +137,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 +222,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. */

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;
 }
 

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;

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) &&

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 {
@@ -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