gcc/gcc-rich-location.h

   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)
  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:
 110   text_range_label (const char *text) : m_text (text) {}
 111
 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:
 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:
 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 class 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 */