changed the name of all variables with min/max name (#1606)

* changed the name of all variables with min/max name

Signed-off-by: Parth Lawania <[email protected]>

* removed predeclared ignore condition for min and max identifiers

Signed-off-by: Parth Lawania <[email protected]>

---------

Signed-off-by: Parth Lawania <[email protected]>
Co-authored-by: Parth Lawania <[email protected]>

Author: parthlaw

.golangci.yml

@@ -66,8 +66,6 @@ linters-settings:
     local-prefixes: github.com/prometheus/client_golang
   gofumpt:
     extra-rules: true
-  predeclared:
-    ignore: "min,max"
   revive:
     rules:
       # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unused-parameter

prometheus/histogram.go

@@ -330,24 +330,24 @@ func ExponentialBuckets(start, factor float64, count int) []float64 {
 // used for the Buckets field of HistogramOpts.
 //
 // The function panics if 'count' is 0 or negative, if 'min' is 0 or negative.
-func ExponentialBucketsRange(min, max float64, count int) []float64 {
+func ExponentialBucketsRange(minBucket, maxBucket float64, count int) []float64 {
 	if count < 1 {
 		panic("ExponentialBucketsRange count needs a positive count")
 	}
-	if min <= 0 {
+	if minBucket <= 0 {
 		panic("ExponentialBucketsRange min needs to be greater than 0")
 	}
 
 	// Formula for exponential buckets.
 	// max = min*growthFactor^(bucketCount-1)
 
 	// We know max/min and highest bucket. Solve for growthFactor.
-	growthFactor := math.Pow(max/min, 1.0/float64(count-1))
+	growthFactor := math.Pow(maxBucket/minBucket, 1.0/float64(count-1))
 
 	// Now that we know growthFactor, solve for each bucket.
 	buckets := make([]float64, count)
 	for i := 1; i <= count; i++ {
-		buckets[i-1] = min * math.Pow(growthFactor, float64(i-1))
+		buckets[i-1] = minBucket * math.Pow(growthFactor, float64(i-1))
 	}
 	return buckets
 }

prometheus/internal/difflib.go

@@ -25,14 +25,14 @@ import (
 	"strings"
 )
 
-func min(a, b int) int {
+func minInt(a, b int) int {
 	if a < b {
 		return a
 	}
 	return b
 }
 
-func max(a, b int) int {
+func maxInt(a, b int) int {
 	if a > b {
 		return a
 	}
@@ -427,12 +427,12 @@ func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
 	if codes[0].Tag == 'e' {
 		c := codes[0]
 		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
+		codes[0] = OpCode{c.Tag, maxInt(i1, i2-n), i2, maxInt(j1, j2-n), j2}
 	}
 	if codes[len(codes)-1].Tag == 'e' {
 		c := codes[len(codes)-1]
 		i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
-		codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
+		codes[len(codes)-1] = OpCode{c.Tag, i1, minInt(i2, i1+n), j1, minInt(j2, j1+n)}
 	}
 	nn := n + n
 	groups := [][]OpCode{}
@@ -443,12 +443,12 @@ func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
 		// there is a large range with no changes.
 		if c.Tag == 'e' && i2-i1 > nn {
 			group = append(group, OpCode{
-				c.Tag, i1, min(i2, i1+n),
-				j1, min(j2, j1+n),
+				c.Tag, i1, minInt(i2, i1+n),
+				j1, minInt(j2, j1+n),
 			})
 			groups = append(groups, group)
 			group = []OpCode{}
-			i1, j1 = max(i1, i2-n), max(j1, j2-n)
+			i1, j1 = maxInt(i1, i2-n), maxInt(j1, j2-n)
 		}
 		group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
 	}
@@ -515,7 +515,7 @@ func (m *SequenceMatcher) QuickRatio() float64 {
 // is faster to compute than either .Ratio() or .QuickRatio().
 func (m *SequenceMatcher) RealQuickRatio() float64 {
 	la, lb := len(m.a), len(m.b)
-	return calculateRatio(min(la, lb), la+lb)
+	return calculateRatio(minInt(la, lb), la+lb)
 }
 
 // Convert range to the "ed" format

prometheus/summary_test.go

@@ -263,12 +263,12 @@ func TestSummaryConcurrency(t *testing.T) {
 			ε := objMap[wantQ]
 			gotQ := *m.Summary.Quantile[i].Quantile
 			gotV := *m.Summary.Quantile[i].Value
-			min, max := getBounds(allVars, wantQ, ε)
+			minBound, maxBound := getBounds(allVars, wantQ, ε)
 			if gotQ != wantQ {
 				t.Errorf("got quantile %f, want %f", gotQ, wantQ)
 			}
-			if gotV < min || gotV > max {
-				t.Errorf("got %f for quantile %f, want [%f,%f]", gotV, gotQ, min, max)
+			if gotV < minBound || gotV > maxBound {
+				t.Errorf("got %f for quantile %f, want [%f,%f]", gotV, gotQ, minBound, maxBound)
 			}
 		}
 		return true
@@ -353,12 +353,12 @@ func TestSummaryVecConcurrency(t *testing.T) {
 				ε := objMap[wantQ]
 				gotQ := *m.Summary.Quantile[j].Quantile
 				gotV := *m.Summary.Quantile[j].Value
-				min, max := getBounds(allVars[i], wantQ, ε)
+				minBound, maxBound := getBounds(allVars[i], wantQ, ε)
 				if gotQ != wantQ {
 					t.Errorf("got quantile %f for label %c, want %f", gotQ, 'A'+i, wantQ)
 				}
-				if gotV < min || gotV > max {
-					t.Errorf("got %f for quantile %f for label %c, want [%f,%f]", gotV, gotQ, 'A'+i, min, max)
+				if gotV < minBound || gotV > maxBound {
+					t.Errorf("got %f for quantile %f for label %c, want [%f,%f]", gotV, gotQ, 'A'+i, minBound, maxBound)
 				}
 			}
 		}
@@ -410,20 +410,20 @@ func TestSummaryDecay(t *testing.T) {
 	}
 }
 
-func getBounds(vars []float64, q, ε float64) (min, max float64) {
+func getBounds(vars []float64, q, ε float64) (minBound, maxBound float64) {
 	// TODO(beorn7): This currently tolerates an error of up to 2*ε. The
 	// error must be at most ε, but for some reason, it's sometimes slightly
 	// higher. That's a bug.
 	n := float64(len(vars))
 	lower := int((q - 2*ε) * n)
 	upper := int(math.Ceil((q + 2*ε) * n))
-	min = vars[0]
+	minBound = vars[0]
 	if lower > 1 {
-		min = vars[lower-1]
+		minBound = vars[lower-1]
 	}
-	max = vars[len(vars)-1]
+	maxBound = vars[len(vars)-1]
 	if upper < len(vars) {
-		max = vars[upper-1]
+		maxBound = vars[upper-1]
 	}
 	return
 }