gcc/gcc/gcc-rich-location.h
David Malcolm 4bc1899b2e Add diagnostic paths
This patch adds support for associating a "diagnostic_path" with a
diagnostic: a sequence of events predicted by the compiler that leads to
the problem occurring, with their locations in the user's source,
text descriptions, and stack information (for handling interprocedural
paths).

For example, the following (hypothetical) error has a 3-event
intraprocedural path:

test.c: In function 'demo':
test.c:29:5: error: passing NULL as argument 1 to 'PyList_Append' which
  requires a non-NULL parameter
   29 |     PyList_Append(list, item);
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~
  'demo': events 1-3
     |
     |   25 |   list = PyList_New(0);
     |      |          ^~~~~~~~~~~~~
     |      |          |
     |      |          (1) when 'PyList_New' fails, returning NULL
     |   26 |
     |   27 |   for (i = 0; i < count; i++) {
     |      |   ~~~
     |      |   |
     |      |   (2) when 'i < count'
     |   28 |     item = PyLong_FromLong(random());
     |   29 |     PyList_Append(list, item);
     |      |     ~~~~~~~~~~~~~~~~~~~~~~~~~
     |      |     |
     |      |     (3) when calling 'PyList_Append', passing NULL from (1) as argument 1
     |

The patch adds a new "%@" format code for printing event IDs, so that
in the above, the description of event (3) mentions event (1), showing
the user where the bogus NULL value comes from (the event IDs are
colorized to draw the user's attention to them).

There is a separation between data vs presentation: the above shows how
the diagnostic-printing code has consolidated the path into a single run
of events, since all the events are near each other and within the same
function; more complicated examples (such as interprocedural paths)
might be printed as multiple runs of events.

Examples of how interprocedural paths are printed can be seen in the
test suite (which uses a plugin to exercise the code without relying
on specific warnings using this functionality).

Other output formats include
- JSON,
- printing each event as a separate "note", and
- to not emit paths.

gcc/ChangeLog:
	* Makefile.in (OBJS): Add tree-diagnostic-path.o.
	* common.opt (fdiagnostics-path-format=): New option.
	(diagnostic_path_format): New enum.
	(fdiagnostics-show-path-depths): New option.
	* coretypes.h (diagnostic_event_id_t): New forward decl.
	* diagnostic-color.c (color_dict): Add "path".
	* diagnostic-event-id.h: New file.
	* diagnostic-format-json.cc (json_from_expanded_location): Make
	non-static.
	(json_end_diagnostic): Call context->make_json_for_path if it
	exists and the diagnostic has a path.
	(diagnostic_output_format_init): Clear context->print_path.
	* diagnostic-path.h: New file.
	* diagnostic-show-locus.c (colorizer::set_range): Special-case
	when printing a run of events in a diagnostic_path so that they
	all get the same color.
	(layout::m_diagnostic_path_p): New field.
	(layout::layout): Initialize it.
	(layout::print_any_labels): Don't colorize the label text for an
	event in a diagnostic_path.
	(gcc_rich_location::add_location_if_nearby): Add
	"restrict_to_current_line_spans" and "label" params.  Pass the
	former to layout.maybe_add_location_range; pass the latter
	when calling add_range.
	* diagnostic.c: Include "diagnostic-path.h".
	(diagnostic_initialize): Initialize context->path_format and
	context->show_path_depths.
	(diagnostic_show_any_path): New function.
	(diagnostic_path::interprocedural_p): New function.
	(diagnostic_report_diagnostic): Call diagnostic_show_any_path.
	(simple_diagnostic_path::num_events): New function.
	(simple_diagnostic_path::get_event): New function.
	(simple_diagnostic_path::add_event): New function.
	(simple_diagnostic_event::simple_diagnostic_event): New ctor.
	(simple_diagnostic_event::~simple_diagnostic_event): New dtor.
	(debug): New overload taking a diagnostic_path *.
	* diagnostic.def (DK_DIAGNOSTIC_PATH): New.
	* diagnostic.h (enum diagnostic_path_format): New enum.
	(json::value): New forward decl.
	(diagnostic_context::path_format): New field.
	(diagnostic_context::show_path_depths): New field.
	(diagnostic_context::print_path): New callback field.
	(diagnostic_context::make_json_for_path): New callback field.
	(diagnostic_show_any_path): New decl.
	(json_from_expanded_location): New decl.
	* doc/invoke.texi (-fdiagnostics-path-format=): New option.
	(-fdiagnostics-show-path-depths): New option.
	(-fdiagnostics-color): Add "path" to description of default
	GCC_COLORS; describe it.
	(-fdiagnostics-format=json): Document how diagnostic paths are
	represented in the JSON output format.
	* gcc-rich-location.h (gcc_rich_location::add_location_if_nearby):
	Add optional params "restrict_to_current_line_spans" and "label".
	* opts.c (common_handle_option): Handle
	OPT_fdiagnostics_path_format_ and
	OPT_fdiagnostics_show_path_depths.
	* pretty-print.c: Include "diagnostic-event-id.h".
	(pp_format): Implement "%@" format code for printing
	diagnostic_event_id_t *.
	(selftest::test_pp_format): Add tests for "%@".
	* selftest-run-tests.c (selftest::run_tests): Call
	selftest::tree_diagnostic_path_cc_tests.
	* selftest.h (selftest::tree_diagnostic_path_cc_tests): New decl.
	* toplev.c (general_init): Initialize global_dc->path_format and
	global_dc->show_path_depths.
	* tree-diagnostic-path.cc: New file.
	* tree-diagnostic.c (maybe_unwind_expanded_macro_loc): Make
	non-static.  Drop "diagnostic" param in favor of storing the
	original value of "where" and re-using it.
	(virt_loc_aware_diagnostic_finalizer): Update for dropped param of
	maybe_unwind_expanded_macro_loc.
	(tree_diagnostics_defaults): Initialize context->print_path and
	context->make_json_for_path.
	* tree-diagnostic.h (default_tree_diagnostic_path_printer): New
	decl.
	(default_tree_make_json_for_path): New decl.
	(maybe_unwind_expanded_macro_loc): New decl.

gcc/c-family/ChangeLog:
	* c-format.c (local_event_ptr_node): New.
	(PP_FORMAT_CHAR_TABLE): Add entry for "%@".
	(init_dynamic_diag_info): Initialize local_event_ptr_node.
	* c-format.h (T_EVENT_PTR): New define.

gcc/testsuite/ChangeLog:
	* gcc.dg/format/gcc_diag-10.c (diagnostic_event_id_t): New
	typedef.
	(test_diag): Add coverage of "%@".
	* gcc.dg/plugin/diagnostic-path-format-default.c: New test.
	* gcc.dg/plugin/diagnostic-path-format-inline-events-1.c: New test.
	* gcc.dg/plugin/diagnostic-path-format-inline-events-2.c: New test.
	* gcc.dg/plugin/diagnostic-path-format-inline-events-3.c: New test.
	* gcc.dg/plugin/diagnostic-path-format-none.c: New test.
	* gcc.dg/plugin/diagnostic-test-paths-1.c: New test.
	* gcc.dg/plugin/diagnostic-test-paths-2.c: New test.
	* gcc.dg/plugin/diagnostic-test-paths-3.c: New test.
	* gcc.dg/plugin/diagnostic-test-paths-4.c: New test.
	* gcc.dg/plugin/diagnostic_plugin_test_paths.c: New.
	* gcc.dg/plugin/plugin.exp: Add the new plugin and test cases.

libcpp/ChangeLog:
	* include/line-map.h (class diagnostic_path): New forward decl.
	(rich_location::get_path): New accessor.
	(rich_location::set_path): New function.
	(rich_location::m_path): New field.
	* line-map.c (rich_location::rich_location): Initialize m_path.

From-SVN: r280142
2020-01-10 21:22:12 +00:00

225 lines
6.2 KiB
C++

/* Declarations relating to class gcc_rich_location
Copyright (C) 2014-2020 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#ifndef GCC_RICH_LOCATION_H
#define GCC_RICH_LOCATION_H
/* A gcc_rich_location is libcpp's rich_location with additional
helper methods for working with gcc's types. */
class gcc_rich_location : public rich_location
{
public:
/* Constructors. */
/* Constructing from a location. */
gcc_rich_location (location_t loc, const range_label *label = NULL)
: rich_location (line_table, loc, label)
{
}
/* Methods for adding ranges via gcc entities. */
void
add_expr (tree expr, range_label *label);
void
maybe_add_expr (tree t, range_label *label);
void add_fixit_misspelled_id (location_t misspelled_token_loc,
tree hint_id);
/* If LOC is within the spans of lines that will already be printed for
this gcc_rich_location, then add it as a secondary location
and return true.
Otherwise return false.
This allows for a diagnostic to compactly print secondary locations
in one diagnostic when these are near enough the primary locations for
diagnostics-show-locus.c to cope with them, and to fall back to
printing them via a note otherwise e.g.:
gcc_rich_location richloc (primary_loc);
bool added secondary = richloc.add_location_if_nearby (secondary_loc);
error_at (&richloc, "main message");
if (!added secondary)
inform (secondary_loc, "message for secondary");
Implemented in diagnostic-show-locus.c. */
bool add_location_if_nearby (location_t loc,
bool restrict_to_current_line_spans = true,
const range_label *label = NULL);
/* Add a fix-it hint suggesting the insertion of CONTENT before
INSERTION_POINT.
Attempt to handle formatting: if INSERTION_POINT is the first thing on
its line, and INDENT is sufficiently sane, then add CONTENT on its own
line, using the indentation of INDENT.
Otherwise, add CONTENT directly before INSERTION_POINT.
For example, adding "CONTENT;" with the closing brace as the insertion
point and using "INDENT;" for indentation:
if ()
{
INDENT;
}
would lead to:
if ()
{
INDENT;
CONTENT;
}
but adding it to:
if () {INDENT;}
would lead to:
if () {INDENT;CONTENT;}
*/
void add_fixit_insert_formatted (const char *content,
location_t insertion_point,
location_t indent);
};
/* Concrete subclass of libcpp's range_label.
Simple implementation using a string literal. */
class text_range_label : public range_label
{
public:
text_range_label (const char *text) : m_text (text) {}
label_text get_text (unsigned /*range_idx*/) const FINAL OVERRIDE
{
return label_text::borrow (m_text);
}
private:
const char *m_text;
};
/* Concrete subclass of libcpp's range_label for use in
diagnostics involving mismatched types.
Each frontend that uses this should supply its own implementation.
Generate a label describing LABELLED_TYPE. The frontend may use
OTHER_TYPE where appropriate for highlighting the differences between
the two types (analogous to C++'s use of %H and %I with
template types).
Either or both of LABELLED_TYPE and OTHER_TYPE may be NULL_TREE.
If LABELLED_TYPE is NULL_TREE, then there is no label.
For example, this rich_location could use two instances of
range_label_for_type_mismatch:
printf ("arg0: %i arg1: %s arg2: %i",
^~
|
const char *
100, 101, 102);
~~~
|
int
(a) the label for "%s" with LABELLED_TYPE for "const char*" and
(b) the label for "101" with LABELLED TYPE for "int"
where each one uses the other's type as OTHER_TYPE. */
class range_label_for_type_mismatch : public range_label
{
public:
range_label_for_type_mismatch (tree labelled_type, tree other_type)
: m_labelled_type (labelled_type), m_other_type (other_type)
{
}
label_text get_text (unsigned range_idx) const OVERRIDE;
protected:
tree m_labelled_type;
tree m_other_type;
};
/* Subclass of range_label for labelling the type of EXPR when reporting
a type mismatch between EXPR and OTHER_EXPR.
Either or both of EXPR and OTHER_EXPR could be NULL. */
class maybe_range_label_for_tree_type_mismatch : public range_label
{
public:
maybe_range_label_for_tree_type_mismatch (tree expr, tree other_expr)
: m_expr (expr), m_other_expr (other_expr)
{
}
label_text get_text (unsigned range_idx) const FINAL OVERRIDE;
private:
tree m_expr;
tree m_other_expr;
};
class op_location_t;
/* A subclass of rich_location for showing problems with binary operations.
If enough location information is available, the ctor will make a
3-location rich_location of the form:
arg_0 op arg_1
~~~~~ ^~ ~~~~~
| |
| arg1 type
arg0 type
labelling the types of the arguments if SHOW_TYPES is true.
Otherwise, it will fall back to a 1-location rich_location using the
compound location within LOC:
arg_0 op arg_1
~~~~~~^~~~~~~~
for which we can't label the types. */
class binary_op_rich_location : public gcc_rich_location
{
public:
binary_op_rich_location (const op_location_t &loc,
tree arg0, tree arg1,
bool show_types);
private:
static bool use_operator_loc_p (const op_location_t &loc,
tree arg0, tree arg1);
maybe_range_label_for_tree_type_mismatch m_label_for_arg0;
maybe_range_label_for_tree_type_mismatch m_label_for_arg1;
};
#endif /* GCC_RICH_LOCATION_H */