Simplify code in a few places

Found by running `gosimple ./...`

crypto/cert_compression.go

@@ -142,7 +142,7 @@ func decompressChain(data []byte) ([][]byte, error) {
 	}
 
 	if numCerts == 0 {
-		return make([][]byte, 0, 0), nil
+		return make([][]byte, 0), nil
 	}
 
 	if hasCompressedCerts {
@@ -255,7 +255,7 @@ func splitHashes(hashes []byte) ([]uint64, error) {
 }
 
 func getCommonCertificateHashes() []byte {
-	ccs := make([]byte, 8*len(certSets), 8*len(certSets))
+	ccs := make([]byte, 8*len(certSets))
 	i := 0
 	for certSetHash := range certSets {
 		binary.LittleEndian.PutUint64(ccs[i*8:(i+1)*8], certSetHash)

crypto/cert_manager.go

@@ -41,7 +41,7 @@ func (c *certManager) SetData(data []byte) error {
 		return qerr.Error(qerr.InvalidCryptoMessageParameter, "Certificate data invalid")
 	}
 
-	chain := make([]*x509.Certificate, len(byteChain), len(byteChain))
+	chain := make([]*x509.Certificate, len(byteChain))
 	for i, data := range byteChain {
 		cert, err := x509.ParseCertificate(data)
 		if err != nil {

example/main.go

@@ -71,8 +71,7 @@ func init() {
 	// maximum accepted file size is 1 GB
 	http.HandleFunc("/demo/upload", func(w http.ResponseWriter, r *http.Request) {
 		if r.Method == http.MethodPost {
-			var err error
-			err = r.ParseMultipartForm(1 << 30) // 1 GB
+			err := r.ParseMultipartForm(1 << 30) // 1 GB
 			if err == nil {
 				var file multipart.File
 				file, _, err = r.FormFile("uploadfile")
@@ -86,7 +85,7 @@ func init() {
 						fmt.Fprintf(w, "%x", md5)
 						return
 					}
-					err = errors.New("Couldn't get uploaded file size.")
+					err = errors.New("couldn't get uploaded file size")
 				}
 			}
 			if err != nil {

flowcontrol/flow_controller.go

@@ -162,7 +162,7 @@ func (c *flowController) maybeAdjustWindowIncrement() {
 		return
 	}
 
-	timeSinceLastWindowUpdate := time.Now().Sub(c.lastWindowUpdateTime)
+	timeSinceLastWindowUpdate := time.Since(c.lastWindowUpdateTime)
 
 	// interval between the window updates is sufficiently large, no need to increase the increment
 	if timeSinceLastWindowUpdate >= 2*rtt {
@@ -194,8 +194,5 @@ func (c *flowController) EnsureMinimumWindowIncrement(inc protocol.ByteCount) {
 }
 
 func (c *flowController) CheckFlowControlViolation() bool {
-	if c.highestReceived > c.receiveWindow {
-		return true
-	}
-	return false
+	return c.highestReceived > c.receiveWindow
 }

frames/ack_frame.go

@@ -222,7 +222,7 @@ func (f *AckFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error
 		utils.WriteUint48(b, uint64(f.LargestAcked))
 	}
 
-	f.DelayTime = time.Now().Sub(f.PacketReceivedTime)
+	f.DelayTime = time.Since(f.PacketReceivedTime)
 	utils.WriteUfloat16(b, uint64(f.DelayTime/time.Microsecond))
 
 	var numRanges uint64
@@ -332,8 +332,7 @@ func (f *AckFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error
 
 // MinLength of a written frame
 func (f *AckFrame) MinLength(version protocol.VersionNumber) (protocol.ByteCount, error) {
-	var length protocol.ByteCount
-	length = 1 + 2 + 1 // 1 TypeByte, 2 ACK delay time, 1 Num Timestamp
+	length := protocol.ByteCount(1 + 2 + 1) // 1 TypeByte, 2 ACK delay time, 1 Num Timestamp
 	length += protocol.ByteCount(protocol.GetPacketNumberLength(f.LargestAcked))
 
 	missingSequenceNumberDeltaLen := protocol.ByteCount(f.getMissingSequenceNumberDeltaLen())
@@ -351,10 +350,7 @@ func (f *AckFrame) MinLength(version protocol.VersionNumber) (protocol.ByteCount
 
 // HasMissingRanges returns if this frame reports any missing packets
 func (f *AckFrame) HasMissingRanges() bool {
-	if len(f.AckRanges) > 0 {
-		return true
-	}
-	return false
+	return len(f.AckRanges) > 0
 }
 
 func (f *AckFrame) validateAckRanges() bool {

frames/stop_waiting_frame.go

@@ -56,8 +56,7 @@ func (f *StopWaitingFrame) Write(b *bytes.Buffer, version protocol.VersionNumber
 
 // MinLength of a written frame
 func (f *StopWaitingFrame) MinLength(version protocol.VersionNumber) (protocol.ByteCount, error) {
-	var minLength protocol.ByteCount
-	minLength = 1 // typeByte
+	minLength := protocol.ByteCount(1) // typeByte
 
 	if f.PacketNumberLen == protocol.PacketNumberLenInvalid {
 		return 0, errPacketNumberLenNotSet

handshake/crypto_setup_client.go

@@ -413,7 +413,7 @@ func (h *cryptoSetupClient) getTags() (map[Tag][]byte, error) {
 		tags[TagCCS] = ccs
 	}
 
-	versionTag := make([]byte, 4, 4)
+	versionTag := make([]byte, 4)
 	binary.LittleEndian.PutUint32(versionTag, protocol.VersionNumberToTag(h.version))
 	tags[TagVER] = versionTag
 
@@ -431,7 +431,7 @@ func (h *cryptoSetupClient) getTags() (map[Tag][]byte, error) {
 		leafCert := h.certManager.GetLeafCert()
 		if leafCert != nil {
 			certHash, _ := h.certManager.GetLeafCertHash()
-			xlct := make([]byte, 8, 8)
+			xlct := make([]byte, 8)
 			binary.LittleEndian.PutUint64(xlct, certHash)
 
 			tags[TagNONC] = h.nonc

handshake/crypto_setup_server.go

@@ -156,10 +156,7 @@ func (h *cryptoSetupServer) handleMessage(chloData []byte, cryptoData map[Tag][]
 		return false, err
 	}
 	_, err = h.cryptoStream.Write(reply)
-	if err != nil {
 	return false, err
-	}
-	return false, nil
 }
 
 // Open a message

handshake/ephermal_cache.go

@@ -29,14 +29,14 @@ func getEphermalKEX() (res crypto.KeyExchange) {
 	res = kexCurrent
 	t := kexCurrentTime
 	kexMutex.RUnlock()
-	if res != nil && time.Now().Sub(t) < kexLifetime {
+	if res != nil && time.Since(t) < kexLifetime {
 		return res
 	}
 
 	kexMutex.Lock()
 	defer kexMutex.Unlock()
 	// Check if still unfulfilled
-	if kexCurrent == nil || time.Now().Sub(kexCurrentTime) > kexLifetime {
+	if kexCurrent == nil || time.Since(kexCurrentTime) > kexLifetime {
 		kex, err := crypto.NewCurve25519KEX()
 		if err != nil {
 			utils.Errorf("could not set KEX: %s", err.Error())

integrationtests/client_test.go

@@ -16,11 +16,7 @@ import (
 
 var _ = Describe("Client tests", func() {
 	var client *http.Client
-	var supportedVersions []protocol.VersionNumber
-
-	for _, v := range protocol.SupportedVersions {
-		supportedVersions = append(supportedVersions, v)
-	}
+	supportedVersions := append([]protocol.VersionNumber{}, protocol.SupportedVersions...)
 
 	BeforeEach(func() {
 		err := os.Setenv("HOSTALIASES", "quic.clemente.io 127.0.0.1")

session.go

@@ -169,8 +169,7 @@ func (s *session) setup() {
 	s.rttStats = &congestion.RTTStats{}
 	flowControlManager := flowcontrol.NewFlowControlManager(s.connectionParameters, s.rttStats)
 
-	var sentPacketHandler ackhandler.SentPacketHandler
-	sentPacketHandler = ackhandler.NewSentPacketHandler(s.rttStats)
+	sentPacketHandler := ackhandler.NewSentPacketHandler(s.rttStats)
 
 	now := time.Now()
 
@@ -447,11 +446,7 @@ func (s *session) handleStreamFrame(frame *frames.StreamFrame) error {
 		// ignore this StreamFrame
 		return nil
 	}
-	err = str.AddStreamFrame(frame)
-	if err != nil {
-		return err
-	}
-	return nil
+	return str.AddStreamFrame(frame)
 }
 
 func (s *session) handleWindowUpdateFrame(frame *frames.WindowUpdateFrame) error {
@@ -482,10 +477,7 @@ func (s *session) handleRstStreamFrame(frame *frames.RstStreamFrame) error {
 }
 
 func (s *session) handleAckFrame(frame *frames.AckFrame) error {
-	if err := s.sentPacketHandler.ReceivedAck(frame, s.lastRcvdPacketNumber, s.lastNetworkActivityTime); err != nil {
-		return err
-	}
-	return nil
+	return s.sentPacketHandler.ReceivedAck(frame, s.lastRcvdPacketNumber, s.lastNetworkActivityTime)
 }
 
 // Close the connection. If err is nil it will be set to qerr.PeerGoingAway.

streams_map.go

@@ -213,10 +213,7 @@ func (m *streamsMap) Iterate(fn streamLambda) error {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
-	openStreams := make([]protocol.StreamID, len(m.openStreams), len(m.openStreams))
-	for i, streamID := range m.openStreams { // copy openStreams
-		openStreams[i] = streamID
-	}
+	openStreams := append([]protocol.StreamID{}, m.openStreams...)
 
 	for _, streamID := range openStreams {
 		cont, err := m.iterateFunc(streamID, fn)

utils/connection_id.go

@@ -9,7 +9,7 @@ import (
 
 // GenerateConnectionID generates a connection ID using cryptographic random
 func GenerateConnectionID() (protocol.ConnectionID, error) {
-	b := make([]byte, 8, 8)
+	b := make([]byte, 8)
 	_, err := rand.Read(b)
 	if err != nil {
 		return 0, err