-
Notifications
You must be signed in to change notification settings - Fork 9.5k
/
consolidate_warnings.go
146 lines (128 loc) · 4.59 KB
/
consolidate_warnings.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package tfdiags
import "fmt"
// ConsolidateWarnings checks if there is an unreasonable amount of warnings
// with the same summary in the receiver and, if so, returns a new diagnostics
// with some of those warnings consolidated into a single warning in order
// to reduce the verbosity of the output.
//
// This mechanism is here primarily for diagnostics printed out at the CLI. In
// other contexts it is likely better to just return the warnings directly,
// particularly if they are going to be interpreted by software rather than
// by a human reader.
//
// The returned slice always has a separate backing array from the reciever,
// but some diagnostic values themselves might be shared.
//
// The definition of "unreasonable" is given as the threshold argument. At most
// that many warnings with the same summary will be shown.
func (diags Diagnostics) ConsolidateWarnings(threshold int) Diagnostics {
if len(diags) == 0 {
return nil
}
newDiags := make(Diagnostics, 0, len(diags))
// We'll track how many times we've seen each warning summary so we can
// decide when to start consolidating. Once we _have_ started consolidating,
// we'll also track the object representing the consolidated warning
// so we can continue appending to it.
warningStats := make(map[string]int)
warningGroups := make(map[string]*warningGroup)
for _, diag := range diags {
severity := diag.Severity()
if severity != Warning || diag.Source().Subject == nil {
// Only warnings can get special treatment, and we only
// consolidate warnings that have source locations because
// our primary goal here is to deal with the situation where
// some configuration language feature is producing a warning
// each time it's used across a potentially-large config.
newDiags = newDiags.Append(diag)
continue
}
desc := diag.Description()
summary := desc.Summary
if g, ok := warningGroups[summary]; ok {
// We're already grouping this one, so we'll just continue it.
g.Append(diag)
continue
}
warningStats[summary]++
if warningStats[summary] == threshold {
// Initially creating the group doesn't really change anything
// visibly in the result, since a group with only one warning
// is just a passthrough anyway, but once we do this any additional
// warnings with the same summary will get appended to this group.
g := &warningGroup{}
newDiags = newDiags.Append(g)
warningGroups[summary] = g
g.Append(diag)
continue
}
// If this warning is not consolidating yet then we'll just append
// it directly.
newDiags = newDiags.Append(diag)
}
return newDiags
}
// A warningGroup is one or more warning diagnostics grouped together for
// UI consolidation purposes.
//
// A warningGroup with only one diagnostic in it is just a passthrough for
// that one diagnostic. If it has more than one then it will behave mostly
// like the first one but its detail message will include an additional
// sentence mentioning the consolidation. A warningGroup with no diagnostics
// at all is invalid and will panic when used.
type warningGroup struct {
Warnings Diagnostics
}
var _ Diagnostic = (*warningGroup)(nil)
func (wg *warningGroup) Severity() Severity {
return wg.Warnings[0].Severity()
}
func (wg *warningGroup) Description() Description {
desc := wg.Warnings[0].Description()
if len(wg.Warnings) < 2 {
return desc
}
extraCount := len(wg.Warnings) - 1
var msg string
switch extraCount {
case 1:
msg = "(and one more similar warning elsewhere)"
default:
msg = fmt.Sprintf("(and %d more similar warnings elsewhere)", extraCount)
}
if desc.Detail != "" {
desc.Detail = desc.Detail + "\n\n" + msg
} else {
desc.Detail = msg
}
return desc
}
func (wg *warningGroup) Source() Source {
return wg.Warnings[0].Source()
}
func (wg *warningGroup) FromExpr() *FromExpr {
return wg.Warnings[0].FromExpr()
}
func (wg *warningGroup) Append(diag Diagnostic) {
if diag.Severity() != Warning {
panic("can't append a non-warning diagnostic to a warningGroup")
}
wg.Warnings = append(wg.Warnings, diag)
}
// WarningGroupSourceRanges can be used in conjunction with
// Diagnostics.ConsolidateWarnings to recover the full set of original source
// locations from a consolidated warning.
//
// For convenience, this function accepts any diagnostic and will just return
// the single Source value from any diagnostic that isn't a warning group.
func WarningGroupSourceRanges(diag Diagnostic) []Source {
wg, ok := diag.(*warningGroup)
if !ok {
return []Source{diag.Source()}
}
ret := make([]Source, len(wg.Warnings))
for i, wrappedDiag := range wg.Warnings {
ret[i] = wrappedDiag.Source()
}
return ret
}