[lldb] Add --exists flag to `settings set`

[JDevlieghere]

Summary

Add a --exists/-e flag to settings set that sets the setting if it
exists, but doesn't print another error otherwise. This is useful when
setting options in your ~/.lldbinit that might not exist in older
versions of lldb.

[jingham]

I suggested what seems to me a slightly clearer help message, but the added option seems useful. I wondered briefly about whether it might be better as a setting settings set ignore-missing-settings but decided that would make it too easy to overlook errors. It's better to do it explicitly for settings you know don't exist in all the the versions of lldb you are likely to be running against.

lldb/source/Commands/Options.td

26

It might be clearer to phrase it focusing on not raising an error if the setting doesn't exist like:

Set the setting if it exists, but do not cause the command to raise an error if it does not exist.

lldb/source/Commands/CommandObjectSettings.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       switch (short_option) {
       case 'f':
         m_force = true;
         break;
       case 'g':
         m_global = true;
         break;
+      case 'e':
+        m_exists = true;
+        break;
       default:
         llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_global = false;
       m_force = false;
+      m_exists = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_settings_set_options);
     }
 
     // Instance variables to hold the values for command options.
     bool m_global = false;
-    bool m_force;
+    bool m_force = false;
+    bool m_exists = false;
   };
 
   void
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
 
     const size_t argc = request.GetParsedLine().GetArgumentCount();
     const char *arg = nullptr;
if (error.Success()) {
       // settings set target.process.python-os-plugin-path) and cause a crash
       // if we did not clear the command's exe_ctx first
       ExecutionContext exe_ctx(m_exe_ctx);
       m_exe_ctx.Clear();
       error = GetDebugger().SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
                                              var_name, var_value);
     }
 
-    if (error.Fail()) {
+    if (error.Fail() && !m_options.m_exists) {
       result.AppendError(error.AsCString());
       return false;
-    } else {
-      result.SetStatus(eReturnStatusSuccessFinishResult);
     }
 
+    result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectSettingsShow -- Show current values

lldb/source/Commands/Options.td

def help_show_hidden : Option<"show-hidden-commands", "h">,
     Desc<"Include commands prefixed with an underscore.">;
 }
 
 let Command = "settings set" in {
   def setset_global : Option<"global", "g">,
     Desc<"Apply the new value to the global default value.">;
   def setset_force : Option<"force", "f">,
     Desc<"Force an empty value to be accepted as the default.">;
+  def setset_exists : Option<"exists", "e">,
+    Desc<"Set the setting if it exists, but do not cause the command to raise "
+    "an error if it does not exist.">;
 }
 
 let Command = "settings write" in {
   def setwrite_file : Option<"file", "f">, Required, Arg<"Filename">,
     Completion<"DiskFile">,
     Desc<"The file into which to write the settings.">;
   def setwrite_append : Option<"append", "a">,
     Desc<"Append to saved settings file if it exists.">;
def target_modules_lookup_function : Option<"function", "F">, Group<4>,
     Arg<"FunctionName">, Required, Desc<"Lookup a function by name in the debug"
     " symbols in one or more target modules.">;
   def target_modules_lookup_name : Option<"name", "n">, Group<5>,
     Arg<"FunctionOrSymbol">, Required, Desc<"Lookup a function or symbol by "
     "name in one or more target modules.">;
   def target_modules_lookup_type : Option<"type", "t">, Group<6>, Arg<"Name">,
     Required, Desc<"Lookup a type by name in the debug symbols in one or more "
     "target modules.">;
-  def target_modules_lookup_variables_ranges : Option<"show-variable-ranges", 
+  def target_modules_lookup_variables_ranges : Option<"show-variable-ranges",
     "\\x01">, GroupRange<1, 6>, Desc<"Dump valid ranges of variables (must be "
     "used in conjunction with --verbose">;
   def target_modules_lookup_verbose : Option<"verbose", "v">,
     Desc<"Enable verbose lookup information.">;
   def target_modules_lookup_all : Option<"all", "A">, Desc<"Print all matches, "
     "not just the best match, if a best match is available.">;
 }
 

lldb/test/API/commands/settings/TestSettings.py

def test_experimental_settings(self):
 
         # A domain component before .experimental. which does not exist should give an error
         # But the code does not yet do that.
         # self.expect('settings set target.setting-which-does-not-exist.experimental.arg0 true', error=True)
 
         # finally, confirm that trying to set a setting that does not exist still fails.
         # (SHOWING a setting that does not exist does not currently yield an error.)
         self.expect('settings set target.setting-which-does-not-exist true', error=True)
+
+    def test_settings_set_exists(self):
+        cmdinterp = self.dbg.GetCommandInterpreter()
+
+        # An unknown option should succeed.
+        self.expect('settings set -e foo bar')
+        self.expect('settings set --exists foo bar')
+
+        # A known option should fail if its argument is invalid.
+        self.expect("settings set auto-confirm bogus", error=True)