|
145
|
1 /* JSON output for diagnostics
|
|
|
2 Copyright (C) 2018-2020 Free Software Foundation, Inc.
|
|
|
3 Contributed by David Malcolm <dmalcolm@redhat.com>.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21
|
|
|
22 #include "config.h"
|
|
|
23 #include "system.h"
|
|
|
24 #include "coretypes.h"
|
|
|
25 #include "diagnostic.h"
|
|
|
26 #include "diagnostic-metadata.h"
|
|
|
27 #include "json.h"
|
|
|
28 #include "selftest.h"
|
|
|
29
|
|
|
30 /* The top-level JSON array of pending diagnostics. */
|
|
|
31
|
|
|
32 static json::array *toplevel_array;
|
|
|
33
|
|
|
34 /* The JSON object for the current diagnostic group. */
|
|
|
35
|
|
|
36 static json::object *cur_group;
|
|
|
37
|
|
|
38 /* The JSON array for the "children" array within the current diagnostic
|
|
|
39 group. */
|
|
|
40
|
|
|
41 static json::array *cur_children_array;
|
|
|
42
|
|
|
43 /* Generate a JSON object for LOC. */
|
|
|
44
|
|
|
45 json::value *
|
|
|
46 json_from_expanded_location (location_t loc)
|
|
|
47 {
|
|
|
48 expanded_location exploc = expand_location (loc);
|
|
|
49 json::object *result = new json::object ();
|
|
|
50 if (exploc.file)
|
|
|
51 result->set ("file", new json::string (exploc.file));
|
|
|
52 result->set ("line", new json::integer_number (exploc.line));
|
|
|
53 result->set ("column", new json::integer_number (exploc.column));
|
|
|
54 return result;
|
|
|
55 }
|
|
|
56
|
|
|
57 /* Generate a JSON object for LOC_RANGE. */
|
|
|
58
|
|
|
59 static json::object *
|
|
|
60 json_from_location_range (const location_range *loc_range, unsigned range_idx)
|
|
|
61 {
|
|
|
62 location_t caret_loc = get_pure_location (loc_range->m_loc);
|
|
|
63
|
|
|
64 if (caret_loc == UNKNOWN_LOCATION)
|
|
|
65 return NULL;
|
|
|
66
|
|
|
67 location_t start_loc = get_start (loc_range->m_loc);
|
|
|
68 location_t finish_loc = get_finish (loc_range->m_loc);
|
|
|
69
|
|
|
70 json::object *result = new json::object ();
|
|
|
71 result->set ("caret", json_from_expanded_location (caret_loc));
|
|
|
72 if (start_loc != caret_loc
|
|
|
73 && start_loc != UNKNOWN_LOCATION)
|
|
|
74 result->set ("start", json_from_expanded_location (start_loc));
|
|
|
75 if (finish_loc != caret_loc
|
|
|
76 && finish_loc != UNKNOWN_LOCATION)
|
|
|
77 result->set ("finish", json_from_expanded_location (finish_loc));
|
|
|
78
|
|
|
79 if (loc_range->m_label)
|
|
|
80 {
|
|
|
81 label_text text;
|
|
|
82 text = loc_range->m_label->get_text (range_idx);
|
|
|
83 if (text.m_buffer)
|
|
|
84 result->set ("label", new json::string (text.m_buffer));
|
|
|
85 text.maybe_free ();
|
|
|
86 }
|
|
|
87
|
|
|
88 return result;
|
|
|
89 }
|
|
|
90
|
|
|
91 /* Generate a JSON object for HINT. */
|
|
|
92
|
|
|
93 static json::object *
|
|
|
94 json_from_fixit_hint (const fixit_hint *hint)
|
|
|
95 {
|
|
|
96 json::object *fixit_obj = new json::object ();
|
|
|
97
|
|
|
98 location_t start_loc = hint->get_start_loc ();
|
|
|
99 fixit_obj->set ("start", json_from_expanded_location (start_loc));
|
|
|
100 location_t next_loc = hint->get_next_loc ();
|
|
|
101 fixit_obj->set ("next", json_from_expanded_location (next_loc));
|
|
|
102 fixit_obj->set ("string", new json::string (hint->get_string ()));
|
|
|
103
|
|
|
104 return fixit_obj;
|
|
|
105 }
|
|
|
106
|
|
|
107 /* Generate a JSON object for METADATA. */
|
|
|
108
|
|
|
109 static json::object *
|
|
|
110 json_from_metadata (const diagnostic_metadata *metadata)
|
|
|
111 {
|
|
|
112 json::object *metadata_obj = new json::object ();
|
|
|
113
|
|
|
114 if (metadata->get_cwe ())
|
|
|
115 metadata_obj->set ("cwe",
|
|
|
116 new json::integer_number (metadata->get_cwe ()));
|
|
|
117
|
|
|
118 return metadata_obj;
|
|
|
119 }
|
|
|
120
|
|
|
121 /* No-op implementation of "begin_diagnostic" for JSON output. */
|
|
|
122
|
|
|
123 static void
|
|
|
124 json_begin_diagnostic (diagnostic_context *, diagnostic_info *)
|
|
|
125 {
|
|
|
126 }
|
|
|
127
|
|
|
128 /* Implementation of "end_diagnostic" for JSON output.
|
|
|
129 Generate a JSON object for DIAGNOSTIC, and store for output
|
|
|
130 within current diagnostic group. */
|
|
|
131
|
|
|
132 static void
|
|
|
133 json_end_diagnostic (diagnostic_context *context, diagnostic_info *diagnostic,
|
|
|
134 diagnostic_t orig_diag_kind)
|
|
|
135 {
|
|
|
136 json::object *diag_obj = new json::object ();
|
|
|
137
|
|
|
138 /* Get "kind" of diagnostic. */
|
|
|
139 {
|
|
|
140 static const char *const diagnostic_kind_text[] = {
|
|
|
141 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
|
|
|
142 #include "diagnostic.def"
|
|
|
143 #undef DEFINE_DIAGNOSTIC_KIND
|
|
|
144 "must-not-happen"
|
|
|
145 };
|
|
|
146 /* Lose the trailing ": ". */
|
|
|
147 const char *kind_text = diagnostic_kind_text[diagnostic->kind];
|
|
|
148 size_t len = strlen (kind_text);
|
|
|
149 gcc_assert (len > 2);
|
|
|
150 gcc_assert (kind_text[len - 2] == ':');
|
|
|
151 gcc_assert (kind_text[len - 1] == ' ');
|
|
|
152 char *rstrip = xstrdup (kind_text);
|
|
|
153 rstrip[len - 2] = '\0';
|
|
|
154 diag_obj->set ("kind", new json::string (rstrip));
|
|
|
155 free (rstrip);
|
|
|
156 }
|
|
|
157
|
|
|
158 // FIXME: encoding of the message (json::string requires UTF-8)
|
|
|
159 diag_obj->set ("message",
|
|
|
160 new json::string (pp_formatted_text (context->printer)));
|
|
|
161 pp_clear_output_area (context->printer);
|
|
|
162
|
|
|
163 char *option_text;
|
|
|
164 option_text = context->option_name (context, diagnostic->option_index,
|
|
|
165 orig_diag_kind, diagnostic->kind);
|
|
|
166 if (option_text)
|
|
|
167 {
|
|
|
168 diag_obj->set ("option", new json::string (option_text));
|
|
|
169 free (option_text);
|
|
|
170 }
|
|
|
171
|
|
|
172 if (context->get_option_url)
|
|
|
173 {
|
|
|
174 char *option_url = context->get_option_url (context,
|
|
|
175 diagnostic->option_index);
|
|
|
176 if (option_url)
|
|
|
177 {
|
|
|
178 diag_obj->set ("option_url", new json::string (option_url));
|
|
|
179 free (option_url);
|
|
|
180 }
|
|
|
181 }
|
|
|
182
|
|
|
183 /* If we've already emitted a diagnostic within this auto_diagnostic_group,
|
|
|
184 then add diag_obj to its "children" array. */
|
|
|
185 if (cur_group)
|
|
|
186 {
|
|
|
187 gcc_assert (cur_children_array);
|
|
|
188 cur_children_array->append (diag_obj);
|
|
|
189 }
|
|
|
190 else
|
|
|
191 {
|
|
|
192 /* Otherwise, make diag_obj be the top-level object within the group;
|
|
|
193 add a "children" array. */
|
|
|
194 toplevel_array->append (diag_obj);
|
|
|
195 cur_group = diag_obj;
|
|
|
196 cur_children_array = new json::array ();
|
|
|
197 diag_obj->set ("children", cur_children_array);
|
|
|
198 }
|
|
|
199
|
|
|
200 const rich_location *richloc = diagnostic->richloc;
|
|
|
201
|
|
|
202 json::array *loc_array = new json::array ();
|
|
|
203 diag_obj->set ("locations", loc_array);
|
|
|
204
|
|
|
205 for (unsigned int i = 0; i < richloc->get_num_locations (); i++)
|
|
|
206 {
|
|
|
207 const location_range *loc_range = richloc->get_range (i);
|
|
|
208 json::object *loc_obj = json_from_location_range (loc_range, i);
|
|
|
209 if (loc_obj)
|
|
|
210 loc_array->append (loc_obj);
|
|
|
211 }
|
|
|
212
|
|
|
213 if (richloc->get_num_fixit_hints ())
|
|
|
214 {
|
|
|
215 json::array *fixit_array = new json::array ();
|
|
|
216 diag_obj->set ("fixits", fixit_array);
|
|
|
217 for (unsigned int i = 0; i < richloc->get_num_fixit_hints (); i++)
|
|
|
218 {
|
|
|
219 const fixit_hint *hint = richloc->get_fixit_hint (i);
|
|
|
220 json::object *fixit_obj = json_from_fixit_hint (hint);
|
|
|
221 fixit_array->append (fixit_obj);
|
|
|
222 }
|
|
|
223 }
|
|
|
224
|
|
|
225 /* TODO: tree-ish things:
|
|
|
226 TODO: functions
|
|
|
227 TODO: inlining information
|
|
|
228 TODO: macro expansion information. */
|
|
|
229
|
|
|
230 if (diagnostic->metadata)
|
|
|
231 {
|
|
|
232 json::object *metadata_obj = json_from_metadata (diagnostic->metadata);
|
|
|
233 diag_obj->set ("metadata", metadata_obj);
|
|
|
234 }
|
|
|
235
|
|
|
236 const diagnostic_path *path = richloc->get_path ();
|
|
|
237 if (path && context->make_json_for_path)
|
|
|
238 {
|
|
|
239 json::value *path_value = context->make_json_for_path (context, path);
|
|
|
240 diag_obj->set ("path", path_value);
|
|
|
241 }
|
|
|
242 }
|
|
|
243
|
|
|
244 /* No-op implementation of "begin_group_cb" for JSON output. */
|
|
|
245
|
|
|
246 static void
|
|
|
247 json_begin_group (diagnostic_context *)
|
|
|
248 {
|
|
|
249 }
|
|
|
250
|
|
|
251 /* Implementation of "end_group_cb" for JSON output. */
|
|
|
252
|
|
|
253 static void
|
|
|
254 json_end_group (diagnostic_context *)
|
|
|
255 {
|
|
|
256 cur_group = NULL;
|
|
|
257 cur_children_array = NULL;
|
|
|
258 }
|
|
|
259
|
|
|
260 /* Callback for final cleanup for JSON output. */
|
|
|
261
|
|
|
262 static void
|
|
|
263 json_final_cb (diagnostic_context *)
|
|
|
264 {
|
|
|
265 /* Flush the top-level array. */
|
|
|
266 toplevel_array->dump (stderr);
|
|
|
267 fprintf (stderr, "\n");
|
|
|
268 delete toplevel_array;
|
|
|
269 toplevel_array = NULL;
|
|
|
270 }
|
|
|
271
|
|
|
272 /* Set the output format for CONTEXT to FORMAT. */
|
|
|
273
|
|
|
274 void
|
|
|
275 diagnostic_output_format_init (diagnostic_context *context,
|
|
|
276 enum diagnostics_output_format format)
|
|
|
277 {
|
|
|
278 switch (format)
|
|
|
279 {
|
|
|
280 default:
|
|
|
281 gcc_unreachable ();
|
|
|
282 case DIAGNOSTICS_OUTPUT_FORMAT_TEXT:
|
|
|
283 /* The default; do nothing. */
|
|
|
284 break;
|
|
|
285
|
|
|
286 case DIAGNOSTICS_OUTPUT_FORMAT_JSON:
|
|
|
287 {
|
|
|
288 /* Set up top-level JSON array. */
|
|
|
289 if (toplevel_array == NULL)
|
|
|
290 toplevel_array = new json::array ();
|
|
|
291
|
|
|
292 /* Override callbacks. */
|
|
|
293 context->begin_diagnostic = json_begin_diagnostic;
|
|
|
294 context->end_diagnostic = json_end_diagnostic;
|
|
|
295 context->begin_group_cb = json_begin_group;
|
|
|
296 context->end_group_cb = json_end_group;
|
|
|
297 context->final_cb = json_final_cb;
|
|
|
298 context->print_path = NULL; /* handled in json_end_diagnostic. */
|
|
|
299
|
|
|
300 /* The metadata is handled in JSON format, rather than as text. */
|
|
|
301 context->show_cwe = false;
|
|
|
302
|
|
|
303 /* The option is handled in JSON format, rather than as text. */
|
|
|
304 context->show_option_requested = false;
|
|
|
305
|
|
|
306 /* Don't colorize the text. */
|
|
|
307 pp_show_color (context->printer) = false;
|
|
|
308 }
|
|
|
309 break;
|
|
|
310 }
|
|
|
311 }
|
|
|
312
|
|
|
313 #if CHECKING_P
|
|
|
314
|
|
|
315 namespace selftest {
|
|
|
316
|
|
|
317 /* We shouldn't call json_from_expanded_location on UNKNOWN_LOCATION,
|
|
|
318 but verify that we handle this gracefully. */
|
|
|
319
|
|
|
320 static void
|
|
|
321 test_unknown_location ()
|
|
|
322 {
|
|
|
323 delete json_from_expanded_location (UNKNOWN_LOCATION);
|
|
|
324 }
|
|
|
325
|
|
|
326 /* Verify that we gracefully handle attempts to serialize bad
|
|
|
327 compound locations. */
|
|
|
328
|
|
|
329 static void
|
|
|
330 test_bad_endpoints ()
|
|
|
331 {
|
|
|
332 location_t bad_endpoints
|
|
|
333 = make_location (BUILTINS_LOCATION,
|
|
|
334 UNKNOWN_LOCATION, UNKNOWN_LOCATION);
|
|
|
335
|
|
|
336 location_range loc_range;
|
|
|
337 loc_range.m_loc = bad_endpoints;
|
|
|
338 loc_range.m_range_display_kind = SHOW_RANGE_WITH_CARET;
|
|
|
339 loc_range.m_label = NULL;
|
|
|
340
|
|
|
341 json::object *obj = json_from_location_range (&loc_range, 0);
|
|
|
342 /* We should have a "caret" value, but no "start" or "finish" values. */
|
|
|
343 ASSERT_TRUE (obj != NULL);
|
|
|
344 ASSERT_TRUE (obj->get ("caret") != NULL);
|
|
|
345 ASSERT_TRUE (obj->get ("start") == NULL);
|
|
|
346 ASSERT_TRUE (obj->get ("finish") == NULL);
|
|
|
347 delete obj;
|
|
|
348 }
|
|
|
349
|
|
|
350 /* Run all of the selftests within this file. */
|
|
|
351
|
|
|
352 void
|
|
|
353 diagnostic_format_json_cc_tests ()
|
|
|
354 {
|
|
|
355 test_unknown_location ();
|
|
|
356 test_bad_endpoints ();
|
|
|
357 }
|
|
|
358
|
|
|
359 } // namespace selftest
|
|
|
360
|
|
|
361 #endif /* #if CHECKING_P */
|
