gcc/gcc-rich-location.h

   1 /* Declarations relating to class gcc_rich_location
   2    Copyright (C) 2014-2018 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 #endif /* GCC_RICH_LOCATION_H */