fix some issues found with staticcheck.io

irc/accounts.go

 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net/smtp"
 	"strconv"
 	} else if callbackNamespace == "mailto" {
 		return am.dispatchMailtoCallback(client, casefoldedAccount, callbackValue)
 	} else {
-		return "", errors.New(fmt.Sprintf("Callback not implemented: %s", callbackNamespace))
+		return "", fmt.Errorf("Callback not implemented: %s", callbackNamespace)
 	}
 }
 
 		}
 	}
 	am.accountToClients[casefoldedAccount] = remainingClients
-	return
 }
 
 var (

irc/channel.go

 	rb.Add(nil, client.server.name, rplendoflist, nick, channel.name, client.t("End of list"))
 }
 
-func (channel *Channel) applyModeMask(client *Client, mode modes.Mode, op modes.ModeOp, mask string, rb *ResponseBuffer) bool {
-	list := channel.lists[mode]
-	if list == nil {
-		// This should never happen, but better safe than panicky.
-		return false
-	}
-
-	if (op == modes.List) || (mask == "") {
-		channel.ShowMaskList(client, mode, rb)
-		return false
-	}
-
-	if !channel.ClientIsAtLeast(client, modes.ChannelOperator) {
-		rb.Add(nil, client.server.name, ERR_CHANOPRIVSNEEDED, client.Nick(), channel.Name(), client.t("You're not a channel operator"))
-		return false
-	}
-
-	if op == modes.Add {
-		return list.Add(mask)
-	}
-
-	if op == modes.Remove {
-		return list.Remove(mask)
-	}
-
-	return false
-}
-
 // Quit removes the given client from the channel
 func (channel *Channel) Quit(client *Client) {
 	channelEmpty := func() bool {

irc/client.go

 func (client *Client) tryResumeChannels() {
 	details := client.resumeDetails
 
-	channels := make([]*Channel, len(details.Channels))
 	for _, name := range details.Channels {
 		channel := client.server.channels.Get(name)
 		if channel == nil {
 			continue
 		}
 		channel.Resume(client, details.OldClient, details.Timestamp)
-		channels = append(channels, channel)
 	}
 
 	// replay direct PRIVSMG history

irc/config.go

 
 			// get inhereted info from other operclasses
 			if len(info.Extends) > 0 {
-				einfo, _ := ocs[info.Extends]
+				einfo := ocs[info.Extends]
 
 				for capab := range einfo.Capabilities {
 					oc.Capabilities[capab] = true

irc/handlers.go

 func isonHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
 	var nicks = msg.Params
 
-	var err error
-	var casefoldedNick string
-	ison := make([]string, 0)
+	ison := make([]string, 0, len(msg.Params))
 	for _, nick := range nicks {
-		casefoldedNick, err = CasefoldName(nick)
-		if err != nil {
-			continue
-		}
-		if iclient := server.clients.Get(casefoldedNick); iclient != nil {
-			ison = append(ison, iclient.nick)
+		if iclient := server.clients.Get(nick); iclient != nil {
+			ison = append(ison, iclient.Nick())
 		}
 	}
 
-	rb.Add(nil, server.name, RPL_ISON, client.nick, strings.Join(nicks, " "))
+	rb.Add(nil, server.name, RPL_ISON, client.nick, strings.Join(ison, " "))
 	return false
 }
 
 
 // OPER <name> <password>
 func operHandler(server *Server, client *Client, msg ircmsg.IrcMessage, rb *ResponseBuffer) bool {
-	if client.HasMode(modes.Operator) == true {
+	if client.HasMode(modes.Operator) {
 		rb.Add(nil, server.name, ERR_UNKNOWNERROR, client.Nick(), "OPER", client.t("You're already opered-up!"))
 		return false
 	}

irc/modes/modes.go

 			prefixes = target[:i+1]
 			name = target[i+1:]
 		default:
-			break
+			return
 		}
 	}
 

irc/semaphores.go

 		capacity = MaxServerSemaphoreCapacity
 	}
 	serversem.ClientDestroy.Initialize(capacity)
-	return
 }

irc/server.go

 	"github.com/goshuirc/irc-go/ircfmt"
 	"github.com/oragono/oragono/irc/caps"
 	"github.com/oragono/oragono/irc/connection_limits"
-	"github.com/oragono/oragono/irc/isupport"
 	"github.com/oragono/oragono/irc/logger"
 	"github.com/oragono/oragono/irc/modes"
 	"github.com/oragono/oragono/irc/sno"
 	ctime               time.Time
 	dlines              *DLineManager
 	helpIndexManager    HelpIndexManager
-	isupport            *isupport.List
 	klines              *KLineManager
 	listeners           map[string]*ListenerWrapper
 	logger              *logger.Manager
 	monitorManager      *MonitorManager
-	motdLines           []string
 	name                string
 	nameCasefolded      string
 	rehashMutex         sync.Mutex // tier 4
 	return
 }
 
-func loadChannelList(channel *Channel, list string, maskMode modes.Mode) {
-	if list == "" {
-		return
-	}
-	channel.lists[maskMode].AddAll(strings.Split(list, " "))
-}
-
 // Shutdown shuts down the server.
 func (server *Server) Shutdown() {
 	//TODO(dan): Make sure we disallow new nicks
 	tLanguages := target.Languages()
 	if 0 < len(tLanguages) {
 		params := []string{cnick, tnick}
-		for _, str := range client.server.Languages().Codes(tLanguages) {
-			params = append(params, str)
-		}
+		params = append(params, client.server.Languages().Codes(tLanguages)...)
 		params = append(params, client.t("can speak these languages"))
 		rb.Add(nil, client.server.name, RPL_WHOISLANGUAGE, params...)
 	}

irc/snomanager.go

 	for _, mask := range masks {
 		currentClientList := m.sendLists[mask]
 
-		if currentClientList == nil || len(currentClientList) == 0 {
+		if len(currentClientList) == 0 {
 			continue
 		}
 
 	for mask := range m.sendLists {
 		currentClientList := m.sendLists[mask]
 
-		if currentClientList == nil || len(currentClientList) == 0 {
+		if len(currentClientList) == 0 {
 			continue
 		}
 
 
 	currentClientList := m.sendLists[mask]
 
-	if currentClientList == nil || len(currentClientList) == 0 {
+	if len(currentClientList) == 0 {
 		return
 	}