gcc/spellcheck.h

   1 /* Find near-matches for strings and identifiers.
   2    Copyright (C) 2015-2023 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_SPELLCHECK_H
  21 #define GCC_SPELLCHECK_H
  22
  23 typedef unsigned int edit_distance_t;
  24 const edit_distance_t MAX_EDIT_DISTANCE = UINT_MAX;
  25
  26 /* spellcheck.cc  */
  27 extern edit_distance_t
  28 get_edit_distance (const char *s, int len_s,
  29                    const char *t, int len_t);
  30
  31 extern edit_distance_t
  32 get_edit_distance (const char *s, const char *t);
  33
  34 extern const char *
  35 find_closest_string (const char *target,
  36                      const auto_vec<const char *> *candidates);
  37
  38 /* A traits class for describing a string-like type usable by
  39    class best_match.
  40    Specializations should provide the implementations of the following:
  41
  42      static size_t get_length (TYPE);
  43      static const char *get_string (TYPE);
  44
  45    get_string should return a non-NULL ptr, which does not need to be
  46    0-terminated.  */
  47
  48 template <typename TYPE>
  49 struct edit_distance_traits {};
  50
  51 /* Specialization of edit_distance_traits for C-style strings.  */
  52
  53 template <>
  54 struct edit_distance_traits<const char *>
  55 {
  56   static size_t get_length (const char *str)
  57   {
  58     gcc_assert (str);
  59     return strlen (str);
  60   }
  61
  62   static const char *get_string (const char *str)
  63   {
  64     gcc_assert (str);
  65     return str;
  66   }
  67 };
  68
  69 extern edit_distance_t get_edit_distance_cutoff (size_t goal_len,
  70                                                  size_t candidate_len);
  71
  72 /* A type for use when determining the best match against a string,
  73    expressed as a template so that we can match against various
  74    string-like types (const char *, frontend identifiers, and preprocessor
  75    macros).
  76
  77    This type accumulates the best possible match against GOAL_TYPE for
  78    a sequence of elements of CANDIDATE_TYPE, whilst minimizing the
  79    number of calls to get_edit_distance and to
  80    edit_distance_traits<T>::get_length.  */
  81
  82 template <typename GOAL_TYPE, typename CANDIDATE_TYPE>
  83 class best_match
  84 {
  85  public:
  86   typedef GOAL_TYPE goal_t;
  87   typedef CANDIDATE_TYPE candidate_t;
  88   typedef edit_distance_traits<goal_t> goal_traits;
  89   typedef edit_distance_traits<candidate_t> candidate_traits;
  90
  91   /* Constructor.  */
  92
  93   best_match (GOAL_TYPE goal,
  94               edit_distance_t best_distance_so_far = MAX_EDIT_DISTANCE)
  95   : m_goal (goal_traits::get_string (goal)),
  96     m_goal_len (goal_traits::get_length (goal)),
  97     m_best_candidate (NULL),
  98     m_best_distance (best_distance_so_far),
  99     m_best_candidate_len (0)
 100   {}
 101
 102   /* Compare the edit distance between CANDIDATE and m_goal,
 103      and if it's the best so far, record it.  */
 104
 105   void consider (candidate_t candidate)
 106   {
 107     size_t candidate_len = candidate_traits::get_length (candidate);
 108
 109     /* Calculate a lower bound on the candidate's distance to the goal,
 110        based on the difference in lengths; it will require at least
 111        this many insertions/deletions.  */
 112     edit_distance_t min_candidate_distance
 113       = abs ((ssize_t)candidate_len - (ssize_t)m_goal_len);
 114
 115     /* If the candidate's length is sufficiently different to that
 116        of the goal string, then the number of insertions/deletions
 117        may be >= the best distance so far.  If so, we can reject
 118        the candidate immediately without needing to compute
 119        the exact distance, since it won't be an improvement.  */
 120     if (min_candidate_distance >= m_best_distance)
 121       return;
 122
 123     /* If the candidate will be unable to beat the criterion in
 124        get_best_meaningful_candidate, reject it without computing
 125        the exact distance.  */
 126     edit_distance_t cutoff = get_cutoff (candidate_len);
 127     if (min_candidate_distance > cutoff)
 128       return;
 129
 130     /* Otherwise, compute the distance and see if the candidate
 131        has beaten the previous best value.  */
 132     const char *candidate_str = candidate_traits::get_string (candidate);
 133     edit_distance_t dist
 134       = get_edit_distance (m_goal, m_goal_len, candidate_str, candidate_len);
 135
 136     bool is_better = false;
 137     if (dist < m_best_distance)
 138       is_better = true;
 139     else if (dist == m_best_distance)
 140       {
 141         /* Prefer a candidate that inserts a trailing '=',
 142            so that for
 143            "-ftrivial-auto-var-init"
 144            we suggest
 145            "-ftrivial-auto-var-init="
 146            rather than
 147            "-Wtrivial-auto-var-init".  */
 148         /* Prefer a candidate has a difference in trailing sign character.  */
 149         if (candidate_str[candidate_len - 1] == '='
 150             && m_goal[m_goal_len - 1] != '=')
 151           is_better = true;
 152       }
 153
 154     if (is_better)
 155       {
 156         m_best_distance = dist;
 157         m_best_candidate = candidate;
 158         m_best_candidate_len = candidate_len;
 159       }
 160   }
 161
 162   /* Assuming that BEST_CANDIDATE is known to be better than
 163      m_best_candidate, update (without recomputing the edit distance to
 164      the goal).  */
 165
 166   void set_best_so_far (CANDIDATE_TYPE best_candidate,
 167                         edit_distance_t best_distance,
 168                         size_t best_candidate_len)
 169   {
 170     gcc_assert (best_distance < m_best_distance);
 171     m_best_candidate = best_candidate;
 172     m_best_distance = best_distance;
 173     m_best_candidate_len = best_candidate_len;
 174   }
 175
 176   /* Generate the maximum edit distance for which we consider a suggestion
 177      to be meaningful, given a candidate of length CANDIDATE_LEN.  */
 178
 179   edit_distance_t get_cutoff (size_t candidate_len) const
 180   {
 181     return ::get_edit_distance_cutoff (m_goal_len, candidate_len);
 182   }
 183
 184   /* Get the best candidate so far, but applying a filter to ensure
 185      that we return NULL if none of the candidates are close to the goal,
 186      to avoid offering nonsensical suggestions to the user.  */
 187
 188   candidate_t get_best_meaningful_candidate () const
 189   {
 190     /* If the edit distance is too high, the suggestion is likely to be
 191        meaningless.  */
 192     if (m_best_candidate)
 193       {
 194         edit_distance_t cutoff = get_cutoff (m_best_candidate_len);
 195         if (m_best_distance > cutoff)
 196           return NULL;
 197     }
 198
 199     /* If the goal string somehow makes it into the candidate list, offering
 200        it as a suggestion will be nonsensical e.g.
 201          'constexpr' does not name a type; did you mean 'constexpr'?
 202        Ultimately such suggestions are due to bugs in constructing the
 203        candidate list, but as a band-aid, do not offer suggestions for
 204        distance == 0 (where candidate == goal).  */
 205     if (m_best_distance == 0)
 206       return NULL;
 207
 208     return m_best_candidate;
 209   }
 210
 211   /* Get the closest candidate so far, without applying any filtering.  */
 212
 213   candidate_t blithely_get_best_candidate () const
 214   {
 215     return m_best_candidate;
 216   }
 217
 218   edit_distance_t get_best_distance () const { return m_best_distance; }
 219   size_t get_best_candidate_length () const { return m_best_candidate_len; }
 220
 221  private:
 222   const char *m_goal;
 223   size_t m_goal_len;
 224   candidate_t m_best_candidate;
 225   edit_distance_t m_best_distance;
 226   size_t m_best_candidate_len;
 227 };
 228
 229 #endif  /* GCC_SPELLCHECK_H  */