1 /* Declarations relating to class gcc_rich_location 2 Copyright (C) 2014-2019 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_RICH_LOCATION_H 21 #define GCC_RICH_LOCATION_H 22 23 /* A gcc_rich_location is libcpp's rich_location with additional 24 helper methods for working with gcc's types. */ 25 class gcc_rich_location : public rich_location 26 { 27 public: 28 /* Constructors. */ 29 30 /* Constructing from a location. */ 31 gcc_rich_location (location_t loc, const range_label *label = NULL) rich_location(line_table,loc,label)32 : rich_location (line_table, loc, label) 33 { 34 } 35 36 /* Methods for adding ranges via gcc entities. */ 37 void 38 add_expr (tree expr, range_label *label); 39 40 void 41 maybe_add_expr (tree t, range_label *label); 42 43 void add_fixit_misspelled_id (location_t misspelled_token_loc, 44 tree hint_id); 45 46 /* If LOC is within the spans of lines that will already be printed for 47 this gcc_rich_location, then add it as a secondary location 48 and return true. 49 50 Otherwise return false. 51 52 This allows for a diagnostic to compactly print secondary locations 53 in one diagnostic when these are near enough the primary locations for 54 diagnostics-show-locus.c to cope with them, and to fall back to 55 printing them via a note otherwise e.g.: 56 57 gcc_rich_location richloc (primary_loc); 58 bool added secondary = richloc.add_location_if_nearby (secondary_loc); 59 error_at (&richloc, "main message"); 60 if (!added secondary) 61 inform (secondary_loc, "message for secondary"); 62 63 Implemented in diagnostic-show-locus.c. */ 64 65 bool add_location_if_nearby (location_t loc); 66 67 /* Add a fix-it hint suggesting the insertion of CONTENT before 68 INSERTION_POINT. 69 70 Attempt to handle formatting: if INSERTION_POINT is the first thing on 71 its line, and INDENT is sufficiently sane, then add CONTENT on its own 72 line, using the indentation of INDENT. 73 Otherwise, add CONTENT directly before INSERTION_POINT. 74 75 For example, adding "CONTENT;" with the closing brace as the insertion 76 point and using "INDENT;" for indentation: 77 78 if () 79 { 80 INDENT; 81 } 82 83 would lead to: 84 85 if () 86 { 87 INDENT; 88 CONTENT; 89 } 90 91 but adding it to: 92 93 if () {INDENT;} 94 95 would lead to: 96 97 if () {INDENT;CONTENT;} 98 */ 99 void add_fixit_insert_formatted (const char *content, 100 location_t insertion_point, 101 location_t indent); 102 }; 103 104 /* Concrete subclass of libcpp's range_label. 105 Simple implementation using a string literal. */ 106 107 class text_range_label : public range_label 108 { 109 public: text_range_label(const char * text)110 text_range_label (const char *text) : m_text (text) {} 111 get_text(unsigned)112 label_text get_text (unsigned /*range_idx*/) const FINAL OVERRIDE 113 { 114 return label_text (const_cast <char *> (m_text), false); 115 } 116 117 private: 118 const char *m_text; 119 }; 120 121 /* Concrete subclass of libcpp's range_label for use in 122 diagnostics involving mismatched types. 123 124 Each frontend that uses this should supply its own implementation. 125 126 Generate a label describing LABELLED_TYPE. The frontend may use 127 OTHER_TYPE where appropriate for highlighting the differences between 128 the two types (analogous to C++'s use of %H and %I with 129 template types). 130 131 Either or both of LABELLED_TYPE and OTHER_TYPE may be NULL_TREE. 132 If LABELLED_TYPE is NULL_TREE, then there is no label. 133 134 For example, this rich_location could use two instances of 135 range_label_for_type_mismatch: 136 137 printf ("arg0: %i arg1: %s arg2: %i", 138 ^~ 139 | 140 const char * 141 100, 101, 102); 142 ~~~ 143 | 144 int 145 146 (a) the label for "%s" with LABELLED_TYPE for "const char*" and 147 (b) the label for "101" with LABELLED TYPE for "int" 148 where each one uses the other's type as OTHER_TYPE. */ 149 150 class range_label_for_type_mismatch : public range_label 151 { 152 public: range_label_for_type_mismatch(tree labelled_type,tree other_type)153 range_label_for_type_mismatch (tree labelled_type, tree other_type) 154 : m_labelled_type (labelled_type), m_other_type (other_type) 155 { 156 } 157 158 label_text get_text (unsigned range_idx) const OVERRIDE; 159 160 protected: 161 tree m_labelled_type; 162 tree m_other_type; 163 }; 164 165 /* Subclass of range_label for labelling the type of EXPR when reporting 166 a type mismatch between EXPR and OTHER_EXPR. 167 Either or both of EXPR and OTHER_EXPR could be NULL. */ 168 169 class maybe_range_label_for_tree_type_mismatch : public range_label 170 { 171 public: maybe_range_label_for_tree_type_mismatch(tree expr,tree other_expr)172 maybe_range_label_for_tree_type_mismatch (tree expr, tree other_expr) 173 : m_expr (expr), m_other_expr (other_expr) 174 { 175 } 176 177 label_text get_text (unsigned range_idx) const FINAL OVERRIDE; 178 179 private: 180 tree m_expr; 181 tree m_other_expr; 182 }; 183 184 struct op_location_t; 185 186 /* A subclass of rich_location for showing problems with binary operations. 187 188 If enough location information is available, the ctor will make a 189 3-location rich_location of the form: 190 191 arg_0 op arg_1 192 ~~~~~ ^~ ~~~~~ 193 | | 194 | arg1 type 195 arg0 type 196 197 labelling the types of the arguments if SHOW_TYPES is true. 198 199 Otherwise, it will fall back to a 1-location rich_location using the 200 compound location within LOC: 201 202 arg_0 op arg_1 203 ~~~~~~^~~~~~~~ 204 205 for which we can't label the types. */ 206 207 class binary_op_rich_location : public gcc_rich_location 208 { 209 public: 210 binary_op_rich_location (const op_location_t &loc, 211 tree arg0, tree arg1, 212 bool show_types); 213 214 private: 215 static bool use_operator_loc_p (const op_location_t &loc, 216 tree arg0, tree arg1); 217 218 maybe_range_label_for_tree_type_mismatch m_label_for_arg0; 219 maybe_range_label_for_tree_type_mismatch m_label_for_arg1; 220 }; 221 222 #endif /* GCC_RICH_LOCATION_H */ 223