blob: 82d4f52b2d420d0b672e0b5d7bb829c04ddcc9e9 [file] [log] [blame]
/* Implementation of gcc_rich_location class
Copyright (C) 2014-2019 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
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
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
<>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "hash-set.h"
#include "vec.h"
#include "input.h"
#include "alias.h"
#include "symtab.h"
#include "inchash.h"
#include "tree-core.h"
#include "tree.h"
#include "diagnostic-core.h"
#include "gcc-rich-location.h"
#include "print-tree.h"
#include "pretty-print.h"
#include "intl.h"
#include "cpplib.h"
#include "diagnostic.h"
/* Add a range to the rich_location, covering expression EXPR,
using LABEL if non-NULL. */
gcc_rich_location::add_expr (tree expr, range_label *label)
gcc_assert (expr);
if (CAN_HAVE_RANGE_P (expr))
add_range (EXPR_LOCATION (expr), SHOW_RANGE_WITHOUT_CARET, label);
/* If T is an expression, add a range for it to the rich_location,
using LABEL if non-NULL. */
gcc_rich_location::maybe_add_expr (tree t, range_label *label)
if (EXPR_P (t))
add_expr (t, label);
/* Add a fixit hint suggesting replacing the range at MISSPELLED_TOKEN_LOC
with the identifier HINT_ID. */
gcc_rich_location::add_fixit_misspelled_id (location_t misspelled_token_loc,
tree hint_id)
gcc_assert (TREE_CODE (hint_id) == IDENTIFIER_NODE);
add_fixit_replace (misspelled_token_loc, IDENTIFIER_POINTER (hint_id));
/* Return true if there is nothing on LOC's line before LOC. */
static bool
blank_line_before_p (location_t loc)
expanded_location exploc = expand_location (loc);
char_span line = location_get_source_line (exploc.file, exploc.line);
if (!line)
return false;
if (line.length () < (size_t)exploc.column)
return false;
/* Columns are 1-based. */
for (int column = 1; column < exploc.column; ++column)
if (!ISSPACE (line[column - 1]))
return false;
return true;
/* Subroutine of gcc_rich_location::add_fixit_insert_formatted.
Return true if we should add the content on its own line,
false otherwise.
If true is returned then *OUT_START_OF_LINE is written to. */
static bool
use_new_line (location_t insertion_point, location_t indent,
location_t *out_start_of_line)
if (indent == UNKNOWN_LOCATION)
return false;
const line_map *indent_map = linemap_lookup (line_table, indent);
if (linemap_macro_expansion_map_p (indent_map))
return false;
if (!blank_line_before_p (insertion_point))
return false;
/* Locate the start of the line containing INSERTION_POINT. */
const line_map *insertion_point_map
= linemap_lookup (line_table, insertion_point);
if (linemap_macro_expansion_map_p (insertion_point_map))
return false;
const line_map_ordinary *ordmap
= linemap_check_ordinary (insertion_point_map);
expanded_location exploc_insertion_point = expand_location (insertion_point);
location_t start_of_line
= linemap_position_for_line_and_column (line_table, ordmap,
exploc_insertion_point.line, 1);
*out_start_of_line = start_of_line;
return true;
/* Add a fix-it hint suggesting the insertion of CONTENT before
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 "INDENT;" as the indentation point:
if ()
would lead to:
if ()
but adding it to:
if () {INDENT;}
would lead to:
gcc_rich_location::add_fixit_insert_formatted (const char *content,
location_t insertion_point,
location_t indent)
location_t start_of_line;
if (use_new_line (insertion_point, indent, &start_of_line))
/* Add CONTENT on its own line, using the indentation of INDENT. */
/* Generate an insertion string, indenting by the amount INDENT
was indented. */
int indent_column = LOCATION_COLUMN (get_start (indent));
pretty_printer tmp_pp;
pretty_printer *pp = &tmp_pp;
/* Columns are 1-based. */
for (int column = 1; column < indent_column; ++column)
pp_space (pp);
pp_string (pp, content);
pp_newline (pp);
add_fixit_insert_before (start_of_line, pp_formatted_text (pp));
add_fixit_insert_before (insertion_point, content);
/* Implementation of range_label::get_text for
If both expressions are non-NULL, then generate text describing
the first expression's type (using the other expression's type
for comparison, analogous to %H and %I in the C++ frontend, but
on expressions rather than types). */
maybe_range_label_for_tree_type_mismatch::get_text (unsigned range_idx) const
if (m_expr == NULL_TREE
|| !EXPR_P (m_expr))
return label_text (NULL, false);
tree expr_type = TREE_TYPE (m_expr);
tree other_type = NULL_TREE;
if (m_other_expr && EXPR_P (m_other_expr))
other_type = TREE_TYPE (m_other_expr);
range_label_for_type_mismatch inner (expr_type, other_type);
return inner.get_text (range_idx);
/* binary_op_rich_location's ctor.
If use_operator_loc_p (LOC, ARG0, ARG1), then attempt to 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, make a 1-location rich_location using the compound
location within LOC:
arg_0 op arg_1
for which we can't label the types. */
binary_op_rich_location::binary_op_rich_location (const op_location_t &loc,
tree arg0, tree arg1,
bool show_types)
: gcc_rich_location (loc.m_combined_loc),
m_label_for_arg0 (arg0, arg1),
m_label_for_arg1 (arg1, arg0)
/* Default (above) to using the combined loc.
Potentially override it here: if we have location information for the
operator and for both arguments, then split them all out.
Alternatively, override it if we don't have the combined location. */
if (use_operator_loc_p (loc, arg0, arg1))
set_range (0, loc.m_operator_loc, SHOW_RANGE_WITH_CARET);
maybe_add_expr (arg0, show_types ? &m_label_for_arg0 : NULL);
maybe_add_expr (arg1, show_types ? &m_label_for_arg1 : NULL);
/* Determine if binary_op_rich_location's ctor should attempt to make
a 3-location rich_location (the location of the operator and of
the 2 arguments), or fall back to a 1-location rich_location showing
just the combined location of the operation as a whole. */
binary_op_rich_location::use_operator_loc_p (const op_location_t &loc,
tree arg0, tree arg1)
/* If we don't have a combined location, then use the operator location,
and try to add ranges for the operators. */
if (loc.m_combined_loc == UNKNOWN_LOCATION)
return true;
/* If we don't have the operator location, then use the
combined location. */
if (loc.m_operator_loc == UNKNOWN_LOCATION)
return false;
/* We have both operator location and combined location: only use the
operator location if we have locations for both arguments. */
return (EXPR_HAS_LOCATION (arg0)