[lldb][NFC] Make cmd a reference in GenerateOptionUsage

[DavidSpickett]

Summary

Nowhere in lldb do we call this with a null pointer.
If we did, the first line of the function would fault anyway.

[JDevlieghere]

LGTM

lldb/include/lldb/Interpreter/Options.h

public:
   // together, but there may be some required options that are missing (used to
   // verify options that get folded into command aliases).
   bool VerifyPartialOptions(CommandReturnObject &result);
 
   void OutputFormattedUsageText(Stream &strm,
                                 const OptionDefinition &option_def,
                                 uint32_t output_max_columns);
 
-  void GenerateOptionUsage(Stream &strm, CommandObject *cmd,
+  void GenerateOptionUsage(Stream &strm, CommandObject &cmd,
                            uint32_t screen_width);
 
   bool SupportsLongOption(const char *long_option);
 
   // The following two pure virtual functions must be defined by every class
   // that inherits from this class.
 
   virtual llvm::ArrayRef<OptionDefinition> GetDefinitions() {

lldb/source/Commands/CommandObjectDisassemble.cpp

bool CommandObjectDisassemble::DoExecute(Args &command,
 
   result.SetStatus(eReturnStatusSuccessFinishResult);
 
   if (!command.empty()) {
     result.AppendErrorWithFormat(
         "\"disassemble\" arguments are specified as options.\n");
     const int terminal_width =
         GetCommandInterpreter().GetDebugger().GetTerminalWidth();
-    GetOptions()->GenerateOptionUsage(result.GetErrorStream(), this,
+    GetOptions()->GenerateOptionUsage(result.GetErrorStream(), *this,
                                       terminal_width);
     return false;
   }
 
   if (m_options.show_mixed && m_options.num_lines_context == 0)
     m_options.num_lines_context = 2;
 
   // Always show the PC in the disassembly

lldb/source/Commands/CommandObjectFrame.cpp

if (m_options.relative_frame_offset.hasValue()) {
         }
       }
     } else {
       if (command.GetArgumentCount() > 1) {
         result.AppendErrorWithFormat(
             "too many arguments; expected frame-index, saw '%s'.\n",
             command[0].c_str());
         m_options.GenerateOptionUsage(
-            result.GetErrorStream(), this,
+            result.GetErrorStream(), *this,
             GetCommandInterpreter().GetDebugger().GetTerminalWidth());
         return false;
       }
 
       if (command.GetArgumentCount() == 1) {
         if (command[0].ref().getAsInteger(0, frame_idx)) {
           result.AppendErrorWithFormat("invalid frame index argument '%s'.",
                                        command[0].c_str());

lldb/source/Commands/CommandObjectTarget.cpp

case eLookupTypeType:
           result.SetStatus(eReturnStatusSuccessFinishResult);
           return true;
         }
       }
       break;
 
     default:
       m_options.GenerateOptionUsage(
-          result.GetErrorStream(), this,
+          result.GetErrorStream(), *this,
           GetCommandInterpreter().GetDebugger().GetTerminalWidth());
       syntax_error = true;
       break;
     }
 
     result.SetStatus(eReturnStatusFailed);
     return false;
   }

lldb/source/Interpreter/CommandObject.cpp

if (options != nullptr) {
     } else {
       const char *error_cstr = error.AsCString();
       if (error_cstr) {
         // We got an error string, lets use that
         result.AppendError(error_cstr);
       } else {
         // No error string, output the usage information into result
         options->GenerateOptionUsage(
-            result.GetErrorStream(), this,
+            result.GetErrorStream(), *this,
             GetCommandInterpreter().GetDebugger().GetTerminalWidth());
       }
     }
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
   return true;
 }
bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word,
   else if (search_long_help && long_help.contains_insensitive(search_word))
     found_word = true;
   else if (search_syntax && syntax_help.contains_insensitive(search_word))
     found_word = true;
 
   if (!found_word && search_options && GetOptions() != nullptr) {
     StreamString usage_help;
     GetOptions()->GenerateOptionUsage(
-        usage_help, this,
+        usage_help, *this,
         GetCommandInterpreter().GetDebugger().GetTerminalWidth());
     if (!usage_help.Empty()) {
       llvm::StringRef usage_text = usage_help.GetString();
       if (usage_text.contains_insensitive(search_word))
         found_word = true;
     }
   }
 
void CommandObject::GenerateHelpText(Stream &output_strm) {
   if (WantsRawCommandString()) {
     help_text.append("  Expects 'raw' input (see 'help raw-input'.)");
   }
   interpreter.OutputFormattedHelpText(output_strm, "", help_text);
   output_strm << "\nSyntax: " << GetSyntax() << "\n";
   Options *options = GetOptions();
   if (options != nullptr) {
     options->GenerateOptionUsage(
-        output_strm, this,
+        output_strm, *this,
         GetCommandInterpreter().GetDebugger().GetTerminalWidth());
   }
   llvm::StringRef long_help = GetHelpLong();
   if (!long_help.empty()) {
     FormatLongHelpText(output_strm, long_help);
   }
   if (!IsDashDashCommand() && options && options->NumCommandOptions() > 0) {
     if (WantsRawCommandString() && !WantsCompletion()) {

lldb/source/Interpreter/Options.cpp

static bool PrintOption(const OptionDefinition &opt_def,
   }
   if (show_optional && !opt_def.required)
     strm.PutChar(']');
   if (footer && footer[0])
     strm.PutCString(footer);
   return true;
 }
 
-void Options::GenerateOptionUsage(Stream &strm, CommandObject *cmd,
+void Options::GenerateOptionUsage(Stream &strm, CommandObject &cmd,
                                   uint32_t screen_width) {
-  const bool only_print_args = cmd->IsDashDashCommand();
+  const bool only_print_args = cmd.IsDashDashCommand();
 
   auto opt_defs = GetDefinitions();
   const uint32_t save_indent_level = strm.GetIndentLevel();
-  llvm::StringRef name;
-
+  llvm::StringRef name = cmd.GetCommandName();
   StreamString arguments_str;
-
-  if (cmd) {
-    name = cmd->GetCommandName();
-    cmd->GetFormattedCommandArguments(arguments_str);
-  } else
-    name = "";
+  cmd.GetFormattedCommandArguments(arguments_str);
 
   const uint32_t num_options = NumCommandOptions();
   if (num_options == 0)
     return;
 
   if (!only_print_args)
     strm.PutCString("\nCommand Options Usage:\n");
 
for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
 
       opt_set_mask = 1 << opt_set;
       if (opt_set > 0)
         strm.Printf("\n");
       strm.Indent(name);
 
       // Different option sets may require different args.
       StreamString args_str;
-      if (cmd)
-        cmd->GetFormattedCommandArguments(args_str, opt_set_mask);
+      cmd.GetFormattedCommandArguments(args_str, opt_set_mask);
 
       // First go through and print all options that take no arguments as a
       // single string. If a command has "-a" "-b" and "-c", this will show up
       // as [-abc]
 
       // We use a set here so that they will be sorted.
       std::set<int> required_options;
       std::set<int> optional_options;
for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
       // Now go through again, and this time only print the optional options.
       for (auto &def : opt_defs) {
         if (def.usage_mask & opt_set_mask && !def.required &&
             def.option_has_arg != OptionParser::eNoArgument)
           PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
       }
 
       if (args_str.GetSize() > 0) {
-        if (cmd->WantsRawCommandString() && !only_print_args)
+        if (cmd.WantsRawCommandString() && !only_print_args)
           strm.Printf(" --");
 
         strm << " " << args_str.GetString();
         if (only_print_args)
           break;
       }
     }
   }
 
-  if (cmd && (only_print_args || cmd->WantsRawCommandString()) &&
+  if ((only_print_args || cmd.WantsRawCommandString()) &&
       arguments_str.GetSize() > 0) {
     if (!only_print_args)
       strm.PutChar('\n');
     strm.Indent(name);
     strm << " " << arguments_str.GetString();
   }
 
   if (!only_print_args) {