Problem: redundant else after return

Solution: remove else

src/curve_client.cpp

@@ -128,8 +128,8 @@ zmq::mechanism_t::status_t zmq::curve_client_t::status () const
         return mechanism_t::ready;
     if (_state == error_received)
         return mechanism_t::error;
-    else
-        return mechanism_t::handshaking;
+
+    return mechanism_t::handshaking;
 }
 
 int zmq::curve_client_t::produce_hello (msg_t *msg_)

src/ip.cpp

@@ -255,9 +255,9 @@ int zmq::bind_to_device (fd_t s_, const std::string &bound_device_)
     if (rc != 0) {
         assert_success_or_recoverable (s_, rc);
         return -1;
-    } else {
-        return 0;
     }
+    return 0;
+
 #else
     LIBZMQ_UNUSED (s_);
     LIBZMQ_UNUSED (bound_device_);
@@ -550,10 +550,10 @@ int zmq::make_fdpair (fd_t *r_, fd_t *w_)
         errno_assert (errno == ENFILE || errno == EMFILE);
         *w_ = *r_ = -1;
         return -1;
-    } else {
-        *w_ = *r_ = fd;
-        return 0;
     }
+    *w_ = *r_ = fd;
+    return 0;
+
 
 #elif defined ZMQ_HAVE_WINDOWS
 #ifdef ZMQ_HAVE_IPC

src/proxy.cpp

@@ -128,8 +128,8 @@ int forward (class zmq::socket_base_t *from_,
             if (rc < 0) {
                 if (likely (errno == EAGAIN && i > 0))
                     return 0; // End of burst
-                else
-                    return -1;
+
+                return -1;
             }
 
             complete_msg_size += msg_->size ();

src/socket_poller.cpp

@@ -91,11 +91,10 @@ int zmq::socket_poller_t::signaler_fd (fd_t *fd_)
     if (_signaler) {
         *fd_ = _signaler->get_fd ();
         return 0;
-    } else {
-        // Only thread-safe socket types are guaranteed to have a signaler.
-        errno = EINVAL;
-        return -1;
     }
+    // Only thread-safe socket types are guaranteed to have a signaler.
+    errno = EINVAL;
+    return -1;
 }
 
 int zmq::socket_poller_t::add (socket_base_t *socket_,

src/stream_engine_base.cpp

@@ -465,14 +465,13 @@ int zmq::stream_engine_base_t::next_handshake_command (msg_t *msg_)
     if (_mechanism->status () == mechanism_t::error) {
         errno = EPROTO;
         return -1;
-    } else {
-        const int rc = _mechanism->next_handshake_command (msg_);
-
-        if (rc == 0)
-            msg_->set_flags (msg_t::command);
-
-        return rc;
     }
+    const int rc = _mechanism->next_handshake_command (msg_);
+
+    if (rc == 0)
+        msg_->set_flags (msg_t::command);
+
+    return rc;
 }
 
 int zmq::stream_engine_base_t::process_handshake_command (msg_t *msg_)

src/tipc_address.cpp

@@ -108,7 +108,8 @@ int zmq::tipc_address_t::resolve (const char *name_)
         address.addr.nameseq.upper = upper;
         address.scope = TIPC_ZONE_SCOPE;
         return 0;
-    } else if (res == 2 && type > TIPC_RESERVED_TYPES) {
+    }
+    if (res == 2 && type > TIPC_RESERVED_TYPES) {
         address.family = AF_TIPC;
         address.addrtype = TIPC_ADDR_NAME;
         address.addr.name.name.type = type;

src/ws_engine.cpp

@@ -204,8 +204,9 @@ bool zmq::ws_engine_t::select_protocol (char *protocol_)
         _process_msg = static_cast<int (stream_engine_base_t::*) (msg_t *)> (
           &ws_engine_t::process_routing_id_msg);
         return true;
-    } else if (_options.mechanism == ZMQ_NULL
-               && strcmp ("ZWS2.0/NULL", protocol_) == 0) {
+    }
+    if (_options.mechanism == ZMQ_NULL
+        && strcmp ("ZWS2.0/NULL", protocol_) == 0) {
         _mechanism = new (std::nothrow)
           null_mechanism_t (session (), _peer_address, _options);
         alloc_assert (_mechanism);
@@ -510,8 +511,8 @@ bool zmq::ws_engine_t::server_handshake ()
                         _insize--;
 
                         return true;
-                    } else
-                        _server_handshake_state = handshake_error;
+                    }
+                    _server_handshake_state = handshake_error;
                 } else
                     _server_handshake_state = handshake_error;
                 break;
@@ -853,8 +854,8 @@ bool zmq::ws_engine_t::client_handshake ()
                         _insize--;
 
                         return true;
-                    } else
-                        _client_handshake_state = client_handshake_error;
+                    }
+                    _client_handshake_state = client_handshake_error;
                 } else
                     _client_handshake_state = client_handshake_error;
                 break;

src/ws_listener.cpp

@@ -126,8 +126,8 @@ std::string zmq::ws_listener_t::get_socket_name (zmq::fd_t fd_,
 {
     if (_wss)
         return zmq::get_socket_name<wss_address_t> (fd_, socket_end_);
-    else
-        return zmq::get_socket_name<ws_address_t> (fd_, socket_end_);
+
+    return zmq::get_socket_name<ws_address_t> (fd_, socket_end_);
 }
 
 int zmq::ws_listener_t::create_socket (const char *addr_)

src/xsub.cpp

@@ -109,10 +109,9 @@ int zmq::xsub_t::xsetsockopt (int option_,
         }
         _only_first_subscribe = (*static_cast<const int *> (optval_) != 0);
         return 0;
-    } else {
-        errno = EINVAL;
-        return -1;
     }
+    errno = EINVAL;
+    return -1;
 }
 
 int zmq::xsub_t::xsend (msg_t *msg_)

src/zap_client.cpp

@@ -274,8 +274,8 @@ zmq::mechanism_t::status_t zap_client_common_handshake_t::status () const
         return mechanism_t::ready;
     if (state == error_sent)
         return mechanism_t::error;
-    else
-        return mechanism_t::handshaking;
+
+    return mechanism_t::handshaking;
 }
 
 int zap_client_common_handshake_t::zap_msg_available ()

src/zmq.cpp

@@ -1305,9 +1305,8 @@ int zmq_poller_fd (void *poller_, zmq_fd_t *fd_)
         || !(static_cast<zmq::socket_poller_t *> (poller_)->check_tag ())) {
         errno = EFAULT;
         return -1;
-    } else {
-        return static_cast<zmq::socket_poller_t *> (poller_)->signaler_fd (fd_);
     }
+    return static_cast<zmq::socket_poller_t *> (poller_)->signaler_fd (fd_);
 }
 
 //  Peer-specific state