Fix lint errors (#1390)

* use increment and decrement operators.

* remove unnecessary else branches.

* fix package comment with leading space.

* fix receiver names.

* fix error strings.

* remove omittable code.

* remove redundant return statement.

* Revert changes (code is generated.)

* use cfg as receiver name for all config-related types.

* use lsi as the receiver name for the LastSignedInfo type.

types/block.go

@@ -141,9 +141,8 @@ func (b *Block) StringIndented(indent string) string {
 func (b *Block) StringShort() string {
 	if b == nil {
 		return "nil-Block"
-	} else {
-		return fmt.Sprintf("Block#%v", b.Hash())
 	}
+	return fmt.Sprintf("Block#%v", b.Hash())
 }
 
 //-----------------------------------------------------------------------------

types/block_test.go

@@ -29,7 +29,7 @@ func TestValidateBlock(t *testing.T) {
 
 	// tamper with NumTxs
 	block = MakeBlock(h, txs, commit)
-	block.NumTxs += 1
+	block.NumTxs++
 	err = block.ValidateBasic()
 	require.Error(t, err)
 

types/evidence.go

@@ -144,7 +144,7 @@ func (dve *DuplicateVoteEvidence) Verify(chainID string) error {
 
 	// BlockIDs must be different
 	if dve.VoteA.BlockID.Equals(dve.VoteB.BlockID) {
-		return fmt.Errorf("DuplicateVoteEvidence Error: BlockIDs are the same (%v) - not a real duplicate vote!", dve.VoteA.BlockID)
+		return fmt.Errorf("DuplicateVoteEvidence Error: BlockIDs are the same (%v) - not a real duplicate vote", dve.VoteA.BlockID)
 	}
 
 	// Signatures must be valid

types/genesis.go

@@ -37,9 +37,8 @@ type GenesisDoc struct {
 func (genDoc *GenesisDoc) AppState() json.RawMessage {
 	if len(genDoc.AppOptions) > 0 {
 		return genDoc.AppOptions
-	} else {
-		return genDoc.AppStateJSON
 	}
+	return genDoc.AppStateJSON
 }
 
 // SaveAs is a utility method for saving GenensisDoc as a JSON file.

types/part_set.go

@@ -30,12 +30,11 @@ type Part struct {
 func (part *Part) Hash() []byte {
 	if part.hash != nil {
 		return part.hash
-	} else {
-		hasher := ripemd160.New()
-		hasher.Write(part.Bytes) // nolint: errcheck, gas
-		part.hash = hasher.Sum(nil)
-		return part.hash
 	}
+	hasher := ripemd160.New()
+	hasher.Write(part.Bytes) // nolint: errcheck, gas
+	part.hash = hasher.Sum(nil)
+	return part.hash
 }
 
 func (part *Part) String() string {
@@ -129,20 +128,18 @@ func NewPartSetFromHeader(header PartSetHeader) *PartSet {
 func (ps *PartSet) Header() PartSetHeader {
 	if ps == nil {
 		return PartSetHeader{}
-	} else {
-		return PartSetHeader{
-			Total: ps.total,
-			Hash:  ps.hash,
-		}
+	}
+	return PartSetHeader{
+		Total: ps.total,
+		Hash:  ps.hash,
 	}
 }
 
 func (ps *PartSet) HasHeader(header PartSetHeader) bool {
 	if ps == nil {
 		return false
-	} else {
-		return ps.Header().Equals(header)
 	}
+	return ps.Header().Equals(header)
 }
 
 func (ps *PartSet) BitArray() *cmn.BitArray {
@@ -251,7 +248,7 @@ func (psr *PartSetReader) Read(p []byte) (n int, err error) {
 		return n1 + n2, err
 	}
 
-	psr.i += 1
+	psr.i++
 	if psr.i >= len(psr.parts) {
 		return 0, io.EOF
 	}
@@ -262,9 +259,8 @@ func (psr *PartSetReader) Read(p []byte) (n int, err error) {
 func (ps *PartSet) StringShort() string {
 	if ps == nil {
 		return "nil-PartSet"
-	} else {
-		ps.mtx.Lock()
-		defer ps.mtx.Unlock()
-		return fmt.Sprintf("(%v of %v)", ps.Count(), ps.Total())
 	}
+	ps.mtx.Lock()
+	defer ps.mtx.Unlock()
+	return fmt.Sprintf("(%v of %v)", ps.Count(), ps.Total())
 }

types/priv_validator.go

@@ -211,18 +211,18 @@ func LoadPrivValidatorFSWithSigner(filePath string, signerFunc func(PrivValidato
 }
 
 // Save persists the PrivValidatorFS to disk.
-func (privVal *PrivValidatorFS) Save() {
-	privVal.mtx.Lock()
-	defer privVal.mtx.Unlock()
-	privVal.save()
+func (pv *PrivValidatorFS) Save() {
+	pv.mtx.Lock()
+	defer pv.mtx.Unlock()
+	pv.save()
 }
 
-func (privVal *PrivValidatorFS) save() {
-	outFile := privVal.filePath
+func (pv *PrivValidatorFS) save() {
+	outFile := pv.filePath
 	if outFile == "" {
 		panic("Cannot save PrivValidator: filePath not set")
 	}
-	jsonBytes, err := json.Marshal(privVal)
+	jsonBytes, err := json.Marshal(pv)
 	if err != nil {
 		panic(err)
 	}
@@ -234,22 +234,22 @@ func (privVal *PrivValidatorFS) save() {
 
 // Reset resets all fields in the PrivValidatorFS.
 // NOTE: Unsafe!
-func (privVal *PrivValidatorFS) Reset() {
+func (pv *PrivValidatorFS) Reset() {
 	var sig crypto.Signature
-	privVal.LastHeight = 0
-	privVal.LastRound = 0
-	privVal.LastStep = 0
-	privVal.LastSignature = sig
-	privVal.LastSignBytes = nil
-	privVal.Save()
+	pv.LastHeight = 0
+	pv.LastRound = 0
+	pv.LastStep = 0
+	pv.LastSignature = sig
+	pv.LastSignBytes = nil
+	pv.Save()
 }
 
 // SignVote signs a canonical representation of the vote, along with the
 // chainID. Implements PrivValidator.
-func (privVal *PrivValidatorFS) SignVote(chainID string, vote *Vote) error {
-	privVal.mtx.Lock()
-	defer privVal.mtx.Unlock()
-	if err := privVal.signVote(chainID, vote); err != nil {
+func (pv *PrivValidatorFS) SignVote(chainID string, vote *Vote) error {
+	pv.mtx.Lock()
+	defer pv.mtx.Unlock()
+	if err := pv.signVote(chainID, vote); err != nil {
 		return errors.New(cmn.Fmt("Error signing vote: %v", err))
 	}
 	return nil
@@ -257,32 +257,32 @@ func (privVal *PrivValidatorFS) SignVote(chainID string, vote *Vote) error {
 
 // SignProposal signs a canonical representation of the proposal, along with
 // the chainID. Implements PrivValidator.
-func (privVal *PrivValidatorFS) SignProposal(chainID string, proposal *Proposal) error {
-	privVal.mtx.Lock()
-	defer privVal.mtx.Unlock()
-	if err := privVal.signProposal(chainID, proposal); err != nil {
+func (pv *PrivValidatorFS) SignProposal(chainID string, proposal *Proposal) error {
+	pv.mtx.Lock()
+	defer pv.mtx.Unlock()
+	if err := pv.signProposal(chainID, proposal); err != nil {
 		return fmt.Errorf("Error signing proposal: %v", err)
 	}
 	return nil
 }
 
 // returns error if HRS regression or no LastSignBytes. returns true if HRS is unchanged
-func (privVal *PrivValidatorFS) checkHRS(height int64, round int, step int8) (bool, error) {
-	if privVal.LastHeight > height {
+func (pv *PrivValidatorFS) checkHRS(height int64, round int, step int8) (bool, error) {
+	if pv.LastHeight > height {
 		return false, errors.New("Height regression")
 	}
 
-	if privVal.LastHeight == height {
-		if privVal.LastRound > round {
+	if pv.LastHeight == height {
+		if pv.LastRound > round {
 			return false, errors.New("Round regression")
 		}
 
-		if privVal.LastRound == round {
-			if privVal.LastStep > step {
+		if pv.LastRound == round {
+			if pv.LastStep > step {
 				return false, errors.New("Step regression")
-			} else if privVal.LastStep == step {
-				if privVal.LastSignBytes != nil {
-					if privVal.LastSignature.Empty() {
+			} else if pv.LastStep == step {
+				if pv.LastSignBytes != nil {
+					if pv.LastSignature.Empty() {
 						panic("privVal: LastSignature is nil but LastSignBytes is not!")
 					}
 					return true, nil
@@ -297,11 +297,11 @@ func (privVal *PrivValidatorFS) checkHRS(height int64, round int, step int8) (bo
 // signVote checks if the vote is good to sign and sets the vote signature.
 // It may need to set the timestamp as well if the vote is otherwise the same as
 // a previously signed vote (ie. we crashed after signing but before the vote hit the WAL).
-func (privVal *PrivValidatorFS) signVote(chainID string, vote *Vote) error {
+func (pv *PrivValidatorFS) signVote(chainID string, vote *Vote) error {
 	height, round, step := vote.Height, vote.Round, voteToStep(vote)
 	signBytes := vote.SignBytes(chainID)
 
-	sameHRS, err := privVal.checkHRS(height, round, step)
+	sameHRS, err := pv.checkHRS(height, round, step)
 	if err != nil {
 		return err
 	}
@@ -312,11 +312,11 @@ func (privVal *PrivValidatorFS) signVote(chainID string, vote *Vote) error {
 	// If they only differ by timestamp, use last timestamp and signature
 	// Otherwise, return error
 	if sameHRS {
-		if bytes.Equal(signBytes, privVal.LastSignBytes) {
-			vote.Signature = privVal.LastSignature
-		} else if timestamp, ok := checkVotesOnlyDifferByTimestamp(privVal.LastSignBytes, signBytes); ok {
+		if bytes.Equal(signBytes, pv.LastSignBytes) {
+			vote.Signature = pv.LastSignature
+		} else if timestamp, ok := checkVotesOnlyDifferByTimestamp(pv.LastSignBytes, signBytes); ok {
 			vote.Timestamp = timestamp
-			vote.Signature = privVal.LastSignature
+			vote.Signature = pv.LastSignature
 		} else {
 			err = fmt.Errorf("Conflicting data")
 		}
@@ -324,11 +324,11 @@ func (privVal *PrivValidatorFS) signVote(chainID string, vote *Vote) error {
 	}
 
 	// It passed the checks. Sign the vote
-	sig, err := privVal.Sign(signBytes)
+	sig, err := pv.Sign(signBytes)
 	if err != nil {
 		return err
 	}
-	privVal.saveSigned(height, round, step, signBytes, sig)
+	pv.saveSigned(height, round, step, signBytes, sig)
 	vote.Signature = sig
 	return nil
 }
@@ -336,11 +336,11 @@ func (privVal *PrivValidatorFS) signVote(chainID string, vote *Vote) error {
 // signProposal checks if the proposal is good to sign and sets the proposal signature.
 // It may need to set the timestamp as well if the proposal is otherwise the same as
 // a previously signed proposal ie. we crashed after signing but before the proposal hit the WAL).
-func (privVal *PrivValidatorFS) signProposal(chainID string, proposal *Proposal) error {
+func (pv *PrivValidatorFS) signProposal(chainID string, proposal *Proposal) error {
 	height, round, step := proposal.Height, proposal.Round, stepPropose
 	signBytes := proposal.SignBytes(chainID)
 
-	sameHRS, err := privVal.checkHRS(height, round, step)
+	sameHRS, err := pv.checkHRS(height, round, step)
 	if err != nil {
 		return err
 	}
@@ -351,11 +351,11 @@ func (privVal *PrivValidatorFS) signProposal(chainID string, proposal *Proposal)
 	// If they only differ by timestamp, use last timestamp and signature
 	// Otherwise, return error
 	if sameHRS {
-		if bytes.Equal(signBytes, privVal.LastSignBytes) {
-			proposal.Signature = privVal.LastSignature
-		} else if timestamp, ok := checkProposalsOnlyDifferByTimestamp(privVal.LastSignBytes, signBytes); ok {
+		if bytes.Equal(signBytes, pv.LastSignBytes) {
+			proposal.Signature = pv.LastSignature
+		} else if timestamp, ok := checkProposalsOnlyDifferByTimestamp(pv.LastSignBytes, signBytes); ok {
 			proposal.Timestamp = timestamp
-			proposal.Signature = privVal.LastSignature
+			proposal.Signature = pv.LastSignature
 		} else {
 			err = fmt.Errorf("Conflicting data")
 		}
@@ -363,40 +363,40 @@ func (privVal *PrivValidatorFS) signProposal(chainID string, proposal *Proposal)
 	}
 
 	// It passed the checks. Sign the proposal
-	sig, err := privVal.Sign(signBytes)
+	sig, err := pv.Sign(signBytes)
 	if err != nil {
 		return err
 	}
-	privVal.saveSigned(height, round, step, signBytes, sig)
+	pv.saveSigned(height, round, step, signBytes, sig)
 	proposal.Signature = sig
 	return nil
 }
 
 // Persist height/round/step and signature
-func (privVal *PrivValidatorFS) saveSigned(height int64, round int, step int8,
+func (pv *PrivValidatorFS) saveSigned(height int64, round int, step int8,
 	signBytes []byte, sig crypto.Signature) {
 
-	privVal.LastHeight = height
-	privVal.LastRound = round
-	privVal.LastStep = step
-	privVal.LastSignature = sig
-	privVal.LastSignBytes = signBytes
-	privVal.save()
+	pv.LastHeight = height
+	pv.LastRound = round
+	pv.LastStep = step
+	pv.LastSignature = sig
+	pv.LastSignBytes = signBytes
+	pv.save()
 }
 
 // SignHeartbeat signs a canonical representation of the heartbeat, along with the chainID.
 // Implements PrivValidator.
-func (privVal *PrivValidatorFS) SignHeartbeat(chainID string, heartbeat *Heartbeat) error {
-	privVal.mtx.Lock()
-	defer privVal.mtx.Unlock()
+func (pv *PrivValidatorFS) SignHeartbeat(chainID string, heartbeat *Heartbeat) error {
+	pv.mtx.Lock()
+	defer pv.mtx.Unlock()
 	var err error
-	heartbeat.Signature, err = privVal.Sign(heartbeat.SignBytes(chainID))
+	heartbeat.Signature, err = pv.Sign(heartbeat.SignBytes(chainID))
 	return err
 }
 
 // String returns a string representation of the PrivValidatorFS.
-func (privVal *PrivValidatorFS) String() string {
-	return fmt.Sprintf("PrivValidator{%v LH:%v, LR:%v, LS:%v}", privVal.GetAddress(), privVal.LastHeight, privVal.LastRound, privVal.LastStep)
+func (pv *PrivValidatorFS) String() string {
+	return fmt.Sprintf("PrivValidator{%v LH:%v, LR:%v, LS:%v}", pv.GetAddress(), pv.LastHeight, pv.LastRound, pv.LastStep)
 }
 
 //-------------------------------------

types/priv_validator/sign_info.go

@@ -49,30 +49,30 @@ func NewLastSignedInfo() *LastSignedInfo {
 	}
 }
 
-func (info *LastSignedInfo) String() string {
-	return fmt.Sprintf("LH:%v, LR:%v, LS:%v", info.Height, info.Round, info.Step)
+func (lsi *LastSignedInfo) String() string {
+	return fmt.Sprintf("LH:%v, LR:%v, LS:%v", lsi.Height, lsi.Round, lsi.Step)
 }
 
 // Verify returns an error if there is a height/round/step regression
 // or if the HRS matches but there are no LastSignBytes.
 // It returns true if HRS matches exactly and the LastSignature exists.
 // It panics if the HRS matches, the LastSignBytes are not empty, but the LastSignature is empty.
-func (info LastSignedInfo) Verify(height int64, round int, step int8) (bool, error) {
-	if info.Height > height {
+func (lsi LastSignedInfo) Verify(height int64, round int, step int8) (bool, error) {
+	if lsi.Height > height {
 		return false, errors.New("Height regression")
 	}
 
-	if info.Height == height {
-		if info.Round > round {
+	if lsi.Height == height {
+		if lsi.Round > round {
 			return false, errors.New("Round regression")
 		}
 
-		if info.Round == round {
-			if info.Step > step {
+		if lsi.Round == round {
+			if lsi.Step > step {
 				return false, errors.New("Step regression")
-			} else if info.Step == step {
-				if info.SignBytes != nil {
-					if info.Signature.Empty() {
+			} else if lsi.Step == step {
+				if lsi.SignBytes != nil {
+					if lsi.Signature.Empty() {
 						panic("info: LastSignature is nil but LastSignBytes is not!")
 					}
 					return true, nil
@@ -85,24 +85,24 @@ func (info LastSignedInfo) Verify(height int64, round int, step int8) (bool, err
 }
 
 // Set height/round/step and signature on the info
-func (info *LastSignedInfo) Set(height int64, round int, step int8,
+func (lsi *LastSignedInfo) Set(height int64, round int, step int8,
 	signBytes []byte, sig crypto.Signature) {
 
-	info.Height = height
-	info.Round = round
-	info.Step = step
-	info.Signature = sig
-	info.SignBytes = signBytes
+	lsi.Height = height
+	lsi.Round = round
+	lsi.Step = step
+	lsi.Signature = sig
+	lsi.SignBytes = signBytes
 }
 
 // Reset resets all the values.
 // XXX: Unsafe.
-func (info *LastSignedInfo) Reset() {
-	info.Height = 0
-	info.Round = 0
-	info.Step = 0
-	info.Signature = crypto.Signature{}
-	info.SignBytes = nil
+func (lsi *LastSignedInfo) Reset() {
+	lsi.Height = 0
+	lsi.Round = 0
+	lsi.Step = 0
+	lsi.Signature = crypto.Signature{}
+	lsi.SignBytes = nil
 }
 
 // SignVote checks the height/round/step (HRS) are greater than the latest state of the LastSignedInfo.

types/validator_set.go

@@ -96,9 +96,8 @@ func (valSet *ValidatorSet) GetByAddress(address []byte) (index int, val *Valida
 	})
 	if idx != len(valSet.Validators) && bytes.Equal(valSet.Validators[idx].Address, address) {
 		return idx, valSet.Validators[idx].Copy()
-	} else {
-		return 0, nil
 	}
+	return 0, nil
 }
 
 // GetByIndex returns the validator by index.
@@ -187,13 +186,12 @@ func (valSet *ValidatorSet) Update(val *Validator) (updated bool) {
 	index, sameVal := valSet.GetByAddress(val.Address)
 	if sameVal == nil {
 		return false
-	} else {
-		valSet.Validators[index] = val.Copy()
-		// Invalidate cache
-		valSet.Proposer = nil
-		valSet.totalVotingPower = 0
-		return true
 	}
+	valSet.Validators[index] = val.Copy()
+	// Invalidate cache
+	valSet.Proposer = nil
+	valSet.totalVotingPower = 0
+	return true
 }
 
 func (valSet *ValidatorSet) Remove(address []byte) (val *Validator, removed bool) {
@@ -202,18 +200,17 @@ func (valSet *ValidatorSet) Remove(address []byte) (val *Validator, removed bool
 	})
 	if idx == len(valSet.Validators) || !bytes.Equal(valSet.Validators[idx].Address, address) {
 		return nil, false
-	} else {
-		removedVal := valSet.Validators[idx]
-		newValidators := valSet.Validators[:idx]
-		if idx+1 < len(valSet.Validators) {
-			newValidators = append(newValidators, valSet.Validators[idx+1:]...)
-		}
-		valSet.Validators = newValidators
-		// Invalidate cache
-		valSet.Proposer = nil
-		valSet.totalVotingPower = 0
-		return removedVal, true
 	}
+	removedVal := valSet.Validators[idx]
+	newValidators := valSet.Validators[:idx]
+	if idx+1 < len(valSet.Validators) {
+		newValidators = append(newValidators, valSet.Validators[idx+1:]...)
+	}
+	valSet.Validators = newValidators
+	// Invalidate cache
+	valSet.Proposer = nil
+	valSet.totalVotingPower = 0
+	return removedVal, true
 }
 
 func (valSet *ValidatorSet) Iterate(fn func(index int, val *Validator) bool) {
@@ -266,10 +263,9 @@ func (valSet *ValidatorSet) VerifyCommit(chainID string, blockID BlockID, height
 
 	if talliedVotingPower > valSet.TotalVotingPower()*2/3 {
 		return nil
-	} else {
-		return fmt.Errorf("Invalid commit -- insufficient voting power: got %v, needed %v",
-			talliedVotingPower, (valSet.TotalVotingPower()*2/3 + 1))
 	}
+	return fmt.Errorf("Invalid commit -- insufficient voting power: got %v, needed %v",
+		talliedVotingPower, (valSet.TotalVotingPower()*2/3 + 1))
 }
 
 // VerifyCommitAny will check to see if the set would
@@ -472,9 +468,8 @@ func safeMulClip(a, b int64) int64 {
 	if overflow {
 		if (a < 0 || b < 0) && !(a < 0 && b < 0) {
 			return math.MinInt64
-		} else {
-			return math.MaxInt64
 		}
+		return math.MaxInt64
 	}
 	return c
 }
@@ -484,9 +479,8 @@ func safeAddClip(a, b int64) int64 {
 	if overflow {
 		if b < 0 {
 			return math.MinInt64
-		} else {
-			return math.MaxInt64
 		}
+		return math.MaxInt64
 	}
 	return c
 }
@@ -496,9 +490,8 @@ func safeSubClip(a, b int64) int64 {
 	if overflow {
 		if b > 0 {
 			return math.MinInt64
-		} else {
-			return math.MaxInt64
 		}
+		return math.MaxInt64
 	}
 	return c
 }

types/validator_set_test.go

@@ -127,7 +127,7 @@ func TestProposerSelection2(t *testing.T) {
 	for i := 0; i < 120*N; i++ {
 		prop := vals.GetProposer()
 		ii := prop.Address[19]
-		propCount[ii] += 1
+		propCount[ii]++
 		vals.IncrementAccum(1)
 	}
 

types/vote_set.go

@@ -94,33 +94,29 @@ func (voteSet *VoteSet) ChainID() string {
 func (voteSet *VoteSet) Height() int64 {
 	if voteSet == nil {
 		return 0
-	} else {
-		return voteSet.height
 	}
+	return voteSet.height
 }
 
 func (voteSet *VoteSet) Round() int {
 	if voteSet == nil {
 		return -1
-	} else {
-		return voteSet.round
 	}
+	return voteSet.round
 }
 
 func (voteSet *VoteSet) Type() byte {
 	if voteSet == nil {
 		return 0x00
-	} else {
-		return voteSet.type_
 	}
+	return voteSet.type_
 }
 
 func (voteSet *VoteSet) Size() int {
 	if voteSet == nil {
 		return 0
-	} else {
-		return voteSet.valSet.Size()
 	}
+	return voteSet.valSet.Size()
 }
 
 // Returns added=true if vote is valid and new.
@@ -185,9 +181,8 @@ func (voteSet *VoteSet) addVote(vote *Vote) (added bool, err error) {
 	if existing, ok := voteSet.getVote(valIndex, blockKey); ok {
 		if existing.Signature.Equals(vote.Signature) {
 			return false, nil // duplicate
-		} else {
-			return false, errors.Wrapf(ErrVoteNonDeterministicSignature, "Existing vote: %v; New vote: %v", existing, vote)
 		}
+		return false, errors.Wrapf(ErrVoteNonDeterministicSignature, "Existing vote: %v; New vote: %v", existing, vote)
 	}
 
 	// Check signature.
@@ -199,13 +194,11 @@ func (voteSet *VoteSet) addVote(vote *Vote) (added bool, err error) {
 	added, conflicting := voteSet.addVerifiedVote(vote, blockKey, val.VotingPower)
 	if conflicting != nil {
 		return added, NewConflictingVoteError(val, conflicting, vote)
-	} else {
-		if !added {
-			cmn.PanicSanity("Expected to add non-conflicting vote")
-		}
-		return added, nil
 	}
-
+	if !added {
+		cmn.PanicSanity("Expected to add non-conflicting vote")
+	}
+	return added, nil
 }
 
 // Returns (vote, true) if vote exists for valIndex and blockKey
@@ -257,13 +250,12 @@ func (voteSet *VoteSet) addVerifiedVote(vote *Vote, blockKey string, votingPower
 			// ... and there's a conflicting vote.
 			// We're not even tracking this blockKey, so just forget it.
 			return false, conflicting
-		} else {
-			// ... and there's no conflicting vote.
-			// Start tracking this blockKey
-			votesByBlock = newBlockVotes(false, voteSet.valSet.Size())
-			voteSet.votesByBlock[blockKey] = votesByBlock
-			// We'll add the vote in a bit.
 		}
+		// ... and there's no conflicting vote.
+		// Start tracking this blockKey
+		votesByBlock = newBlockVotes(false, voteSet.valSet.Size())
+		voteSet.votesByBlock[blockKey] = votesByBlock
+		// We'll add the vote in a bit.
 	}
 
 	// Before adding to votesByBlock, see if we'll exceed quorum
@@ -309,10 +301,9 @@ func (voteSet *VoteSet) SetPeerMaj23(peerID P2PID, blockID BlockID) error {
 	if existing, ok := voteSet.peerMaj23s[peerID]; ok {
 		if existing.Equals(blockID) {
 			return nil // Nothing to do
-		} else {
-			return fmt.Errorf("SetPeerMaj23: Received conflicting blockID from peer %v. Got %v, expected %v",
-				peerID, blockID, existing)
 		}
+		return fmt.Errorf("SetPeerMaj23: Received conflicting blockID from peer %v. Got %v, expected %v",
+			peerID, blockID, existing)
 	}
 	voteSet.peerMaj23s[peerID] = blockID
 
@@ -321,10 +312,9 @@ func (voteSet *VoteSet) SetPeerMaj23(peerID P2PID, blockID BlockID) error {
 	if ok {
 		if votesByBlock.peerMaj23 {
 			return nil // Nothing to do
-		} else {
-			votesByBlock.peerMaj23 = true
-			// No need to copy votes, already there.
 		}
+		votesByBlock.peerMaj23 = true
+		// No need to copy votes, already there.
 	} else {
 		votesByBlock = newBlockVotes(true, voteSet.valSet.Size())
 		voteSet.votesByBlock[blockKey] = votesByBlock
@@ -422,9 +412,8 @@ func (voteSet *VoteSet) TwoThirdsMajority() (blockID BlockID, ok bool) {
 	defer voteSet.mtx.Unlock()
 	if voteSet.maj23 != nil {
 		return *voteSet.maj23, true
-	} else {
-		return BlockID{}, false
 	}
+	return BlockID{}, false
 }
 
 func (voteSet *VoteSet) String() string {