Add spell suggestions to parse_options_baset

This will provide some suggestions if a command line option
is unknown, but similar to an option that *does* exist.

Author: hannes-steffenhagen-diffblue

regression/cbmc/unknown-argument-suggestion/test.desc

@@ -0,0 +1,10 @@
+CORE
+dummy.c
+--traec
+did you mean --trace
+^EXIT=64$
+^SIGNAL=0$
+--
+--
+This checks that we get a useful suggestion when we make a typo on the
+commandline

src/util/cmdline.cpp

@@ -8,6 +8,7 @@ Author: Daniel Kroening, kroening@kroening.com
 
 #include "cmdline.h"
 
+#include <util/edit_distance.h>
 #include <util/exception_utils.h>
 #include <util/invariant.h>
 
@@ -250,6 +251,66 @@ cmdlinet::option_namest cmdlinet::option_names() const
   return option_namest{*this};
 }
 
+std::vector<std::string>
+cmdlinet::get_argument_suggestions(const std::string &unknown_argument)
+{
+  struct suggestiont
+  {
+    std::size_t distance;
+    std::string suggestion;
+
+    bool operator<(const suggestiont &other) const
+    {
+      return distance < other.distance;
+    }
+  };
+
+  auto argument_suggestions = std::vector<suggestiont>{};
+  // We allow 3 errors here. This can lead to the output being a bit chatty,
+  // which we mitigate by reducing suggestions to those with the minimum
+  // distance further down below
+  const auto argument_matcher = levenshtein_automatont{unknown_argument, 3};
+  for(const auto &option : options)
+  {
+    if(option.islong)
+    {
+      const auto long_name = "--" + option.optstring;
+      if(auto distance = argument_matcher.get_edit_distance(long_name))
+      {
+        argument_suggestions.push_back({distance.value(), long_name});
+      }
+    }
+    if(!option.islong)
+    {
+      const auto short_name = std::string{"-"} + option.optchar;
+      if(auto distance = argument_matcher.get_edit_distance(short_name))
+      {
+        argument_suggestions.push_back({distance.value(), short_name});
+      }
+    }
+  }
+
+  auto final_suggestions = std::vector<std::string>{};
+  if(!argument_suggestions.empty())
+  {
+    // we only want to keep suggestions with the minimum distance
+    // because otherwise they become quickly too noisy to be useful
+    auto min = std::min_element(
+      argument_suggestions.begin(), argument_suggestions.end());
+    INVARIANT(
+      min != argument_suggestions.end(),
+      "there is a minimum because it's not empty");
+    for(auto const &suggestion : argument_suggestions)
+    {
+      if(suggestion.distance == min->distance)
+      {
+        final_suggestions.push_back(suggestion.suggestion);
+      }
+    }
+  }
+  return final_suggestions;
+}
+
 cmdlinet::option_namest::option_names_iteratort::option_names_iteratort(
   const cmdlinet *command_line,
   std::size_t index)

src/util/cmdline.h

@@ -94,6 +94,9 @@ class cmdlinet
   cmdlinet();
   virtual ~cmdlinet();
 
+  std::vector<std::string>
+  get_argument_suggestions(const std::string &unknown_argument);
+
 protected:
   struct optiont
   {

src/util/parse_options.cpp

@@ -55,7 +55,22 @@ void parse_options_baset::usage_error()
 void parse_options_baset::unknown_option_msg()
 {
   if(!cmdline.unknown_arg.empty())
-    log.error() << "Unknown option: " << cmdline.unknown_arg << messaget::eom;
+  {
+    log.error() << "Unknown option: " << cmdline.unknown_arg;
+    auto const suggestions =
+      cmdline.get_argument_suggestions(cmdline.unknown_arg);
+    if(!suggestions.empty())
+    {
+      log.error() << ", did you mean ";
+      if(suggestions.size() > 1)
+      {
+        log.error() << "one of ";
+      }
+      join_strings(log.error(), suggestions.begin(), suggestions.end(), ", ");
+      log.error() << "?";
+    }
+    log.error() << messaget::eom;
+  }
 }
 
 int parse_options_baset::main()