clean up nil checks relevant to always-on join

irc/channel.go

 
 	client.addChannel(channel)
 
+	if rb == nil {
+		return
+	}
+
 	var modestr string
 	if givenMode != 0 {
 		modestr = fmt.Sprintf("+%v", givenMode)
 
 	for _, member := range channel.Members() {
 		for _, session := range member.Sessions() {
-			if rb != nil && session == rb.session {
+			if session == rb.session {
 				continue
 			} else if client == session.client {
 				channel.playJoinForSession(session)
 		}
 	}
 
-	if rb != nil && rb.session.capabilities.Has(caps.ExtendedJoin) {
+	if rb.session.capabilities.Has(caps.ExtendedJoin) {
 		rb.AddFromClient(message.Time, message.Msgid, details.nickMask, details.accountName, nil, "JOIN", chname, details.accountName, details.realname)
 	} else {
 		rb.AddFromClient(message.Time, message.Msgid, details.nickMask, details.accountName, nil, "JOIN", chname)
 	}
 
-	if rb != nil && rb.session.client == client {
+	if rb.session.client == client {
 		// don't send topic and names for a SAJOIN of a different client
 		channel.SendTopic(client, rb, false)
 		channel.Names(client, rb)
 	// TODO #259 can be implemented as Flush(false) (i.e., nonblocking) while holding joinPartMutex
 	rb.Flush(true)
 
-	if rb != nil {
-		channel.autoReplayHistory(client, rb, message.Msgid)
-	}
+	channel.autoReplayHistory(client, rb, message.Msgid)
 }
 
 func (channel *Channel) autoReplayHistory(client *Client, rb *ResponseBuffer, skipMsgid string) {

irc/responsebuffer.go

 }
 
 func (rb *ResponseBuffer) AddMessage(msg ircmsg.IrcMessage) {
-	if rb == nil {
-		return
-	}
-
 	if rb.finalized {
 		rb.target.server.logger.Error("internal", "message added to finalized ResponseBuffer, undefined behavior")
 		debug.PrintStack()
 
 // Add adds a standard new message to our queue.
 func (rb *ResponseBuffer) Add(tags map[string]string, prefix string, command string, params ...string) {
-	if rb == nil {
-		return
-	}
-
 	rb.AddMessage(ircmsg.MakeMessage(tags, prefix, command, params...))
 }
 
 // Broadcast adds a standard new message to our queue, then sends an unlabeled copy
 // to all other sessions.
 func (rb *ResponseBuffer) Broadcast(tags map[string]string, prefix string, command string, params ...string) {
-	if rb == nil {
-		return
-	}
-
 	// can't reuse the IrcMessage object because of tag pollution :-\
 	rb.Add(tags, prefix, command, params...)
 	for _, session := range rb.session.client.Sessions() {
 
 // AddFromClient adds a new message from a specific client to our queue.
 func (rb *ResponseBuffer) AddFromClient(time time.Time, msgid string, fromNickMask string, fromAccount string, tags map[string]string, command string, params ...string) {
-	if rb == nil {
-		return
-	}
-
 	msg := ircmsg.MakeMessage(nil, fromNickMask, command, params...)
 	if rb.session.capabilities.Has(caps.MessageTags) {
 		msg.UpdateTags(tags)
 
 // AddSplitMessageFromClient adds a new split message from a specific client to our queue.
 func (rb *ResponseBuffer) AddSplitMessageFromClient(fromNickMask string, fromAccount string, tags map[string]string, command string, target string, message utils.SplitMessage) {
-	if rb == nil {
-		return
-	}
-
 	if message.Is512() {
 		rb.AddFromClient(message.Time, message.Msgid, fromNickMask, fromAccount, tags, command, target, message.Message)
 	} else {
 // Starts a nested batch (see the ResponseBuffer struct definition for a description of
 // how this works)
 func (rb *ResponseBuffer) StartNestedBatch(batchType string, params ...string) (batchID string) {
-	if rb == nil {
-		return
-	}
-
 	batchID = rb.session.generateBatchID()
 	msgParams := make([]string, len(params)+2)
 	msgParams[0] = "+" + batchID
 // Convenience to start a nested batch for history lines, at the highest level
 // supported by the client (`history`, `chathistory`, or no batch, in descending order).
 func (rb *ResponseBuffer) StartNestedHistoryBatch(params ...string) (batchID string) {
-	if rb == nil {
-		return
-	}
-
 	var batchType string
 	if rb.session.capabilities.Has(caps.EventPlayback) {
 		batchType = "history"
 // Afterwards, the buffer is in an undefined state and MUST NOT be used further.
 // If `blocking` is true you MUST be sending to the client from its own goroutine.
 func (rb *ResponseBuffer) Send(blocking bool) error {
-	if rb == nil {
-		return nil
-	}
-
 	return rb.flushInternal(true, blocking)
 }
 
 // to ensure that the final `BATCH -` message is sent.
 // If `blocking` is true you MUST be sending to the client from its own goroutine.
 func (rb *ResponseBuffer) Flush(blocking bool) error {
-	if rb == nil {
-		return nil
-	}
-
 	return rb.flushInternal(false, blocking)
 }
 
 
 // Notice sends the client the given notice from the server.
 func (rb *ResponseBuffer) Notice(text string) {
-	if rb == nil {
-		return
-	}
-
 	rb.Add(nil, rb.target.server.name, "NOTICE", rb.target.Nick(), text)
 }