[lldb][Language] List supported languages in expr error text

[Michael137]

Summary

Before:

(lldb) expr --language abc -- 1 + 1
error: unknown language type: 'abc' for expression

After:

(lldb) expr --language abc -- 1 + 1
error: unknown language type: 'abc' for expression. List of supported languages:
  c++
  objective-c++
  c++03
  c++11
  c++14
  objc++

We choose to only list the languages which expr will actually
accept instead of all the language constants defined in Language.cpp
since that's what the user will most likely need.

[Michael137]

• Use GetLanguagesSupportingTypeSystemsForExpressions instead of GetSupportedLanguages

[Michael137]

• Language name pair can be const &

[aprantl]

Nice. IIUC, this will query every already registered plugin, so it should also work without modification for e.g., LLDB with Swift support.

lldb/include/lldb/Target/Language.h

public:
   GetLanguageTypeFromString(const char *string) = delete;
   static lldb::LanguageType GetLanguageTypeFromString(llvm::StringRef string);
 
   static const char *GetNameForLanguageType(lldb::LanguageType language);
 
   static void PrintAllLanguages(Stream &s, const char *prefix,
                                 const char *suffix);
 
+  /// Prints to the specified stream 's' each language type that the
+  /// current target supports for expression evaluation.
+  ///
+  /// \param[out] s      Stream to which the language types are written.
+  /// \param[in]  prefix String that is prepended to the language type.
+  /// \param[in]  suffix String that is appended to the language type.
+  static void PrintSupportedLanguagesForExpressions(Stream &s,
+                                                    llvm::StringRef prefix,
+                                                    llvm::StringRef suffix);
+
   // return false from callback to stop iterating
   static void ForAllLanguages(std::function<bool(lldb::LanguageType)> callback);
 
   static bool LanguageIsCPlusPlus(lldb::LanguageType language);
 
   static bool LanguageIsObjC(lldb::LanguageType language);
 
   static bool LanguageIsC(lldb::LanguageType language);

lldb/source/Commands/CommandObjectExpression.cpp

Status CommandObjectExpression::CommandOptions::SetOptionValue(
     ExecutionContext *execution_context) {
   Status error;
 
   const int short_option = GetDefinitions()[option_idx].short_option;
 
   switch (short_option) {
   case 'l':
     language = Language::GetLanguageTypeFromString(option_arg);
-    if (language == eLanguageTypeUnknown)
-      error.SetErrorStringWithFormat(
-          "unknown language type: '%s' for expression",
+    if (language == eLanguageTypeUnknown) {
+      StreamString sstr;
+      sstr.Printf("unknown language type: '%s' for expression. "
+                  "List of supported languages:\n",
                   option_arg.str().c_str());
+
+      Language::PrintSupportedLanguagesForExpressions(sstr, "  ", "\n");
+      error.SetErrorString(sstr.GetString());
+    }
     break;
 
   case 'a': {
     bool success;
     bool result;
     result = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (!success)
       error.SetErrorStringWithFormat(

lldb/source/Target/Language.cpp

 
 const char *Language::GetNameForLanguageType(LanguageType language) {
   if (language < num_languages)
     return language_names[language].name;
   else
     return language_names[eLanguageTypeUnknown].name;
 }
 
+void Language::PrintSupportedLanguagesForExpressions(Stream &s,
+                                                     llvm::StringRef prefix,
+                                                     llvm::StringRef suffix) {
+  auto supported = Language::GetLanguagesSupportingTypeSystemsForExpressions();
+  for (size_t idx = 0; idx < num_languages; ++idx) {
+    auto const &lang = language_names[idx];
+    if (supported[lang.type])
+      s << prefix << lang.name << suffix;
+  }
+}
+
 void Language::PrintAllLanguages(Stream &s, const char *prefix,
                                  const char *suffix) {
   for (uint32_t i = 1; i < num_languages; i++) {
     s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
   }
 }
 
 void Language::ForAllLanguages(

lldb/test/API/commands/expression/invalid-args/TestInvalidArgsExpression.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 
 class InvalidArgsExpressionTestCase(TestBase):
 
     @no_debug_info_test
     def test_invalid_lang(self):
         self.expect("expression -l foo --", error=True,
-                    substrs=["error: unknown language type: 'foo' for expression"])
+                    substrs=["error: unknown language type: 'foo' for expression",
+                             "List of supported languages:",
+                             "c++", "c++11", "c++14"])
 
     @no_debug_info_test
     def test_invalid_all_thread(self):
         self.expect("expression -a foo --", error=True,
                     substrs=['error: invalid all-threads value setting: "foo"'])
 
     @no_debug_info_test
     def test_invalid_ignore_br(self):