[lldb] Group debugger properties (NFC)

[JDevlieghere]

Summary

Group debugger properties in one big Doxygen group. Methods relating to different properties are separated by a double newline. Methods relating to the same property are separated by a single newline.

[mib]

nit: Sometimes we have newlines between methods and sometimes we don't ... It would be nice to be consistent, otherwise LGTM

[JDevlieghere]

In D149567#4309195, @mib wrote:

nit: Sometimes we have newlines between methods and sometimes we don't ... It would be nice to be consistent, otherwise LGTM

Methods relating to the same property are grouped together (i.e. no newline) and methods relating to different properties are separated by a newline.

[JDevlieghere]

Use one big Doxygen group for all the properties to make this less noisy.

lldb/include/lldb/Core/Debugger.h

public:
   bool EnableLog(llvm::StringRef channel,
                  llvm::ArrayRef<const char *> categories,
                  llvm::StringRef log_file, uint32_t log_options,
                  size_t buffer_size, LogHandlerKind log_handler_kind,
                  llvm::raw_ostream &error_stream);
 
   void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 
-  // Properties Functions
-  enum StopDisassemblyType {
-    eStopDisassemblyTypeNever = 0,
-    eStopDisassemblyTypeNoDebugInfo,
-    eStopDisassemblyTypeNoSource,
-    eStopDisassemblyTypeAlways
-  };
-
+  /// Debugger properties.
+  /// @{
   Status SetPropertyValue(const ExecutionContext *exe_ctx,
                           VarSetOperationType op, llvm::StringRef property_path,
                           llvm::StringRef value) override;
 
-  bool GetAutoConfirm() const;
-
   const FormatEntity::Entry *GetDisassemblyFormat() const;
-
   const FormatEntity::Entry *GetFrameFormat() const;
-
   const FormatEntity::Entry *GetFrameFormatUnique() const;
-
-  uint32_t GetStopDisassemblyMaxSize() const;
-
   const FormatEntity::Entry *GetThreadFormat() const;
-
   const FormatEntity::Entry *GetThreadStopFormat() const;
 
   lldb::ScriptLanguage GetScriptLanguage() const;
-
   bool SetScriptLanguage(lldb::ScriptLanguage script_lang);
 
   lldb::LanguageType GetREPLLanguage() const;
-
   bool SetREPLLanguage(lldb::LanguageType repl_lang);
 
   uint32_t GetTerminalWidth() const;
-
   bool SetTerminalWidth(uint32_t term_width);
 
   llvm::StringRef GetPrompt() const;
-
   void SetPrompt(llvm::StringRef p);
   void SetPrompt(const char *) = delete;
 
   bool GetUseExternalEditor() const;
-
   bool SetUseExternalEditor(bool use_external_editor_p);
 
   bool GetUseColor() const;
-
   bool SetUseColor(bool use_color);
 
   bool GetShowProgress() const;
-
   bool SetShowProgress(bool show_progress);
 
   llvm::StringRef GetShowProgressAnsiPrefix() const;
-
   llvm::StringRef GetShowProgressAnsiSuffix() const;
 
   bool GetUseAutosuggestion() const;
-
   llvm::StringRef GetAutosuggestionAnsiPrefix() const;
-
   llvm::StringRef GetAutosuggestionAnsiSuffix() const;
 
   bool GetUseSourceCache() const;
-
   bool SetUseSourceCache(bool use_source_cache);
 
   bool GetHighlightSource() const;
 
   lldb::StopShowColumn GetStopShowColumn() const;
-
   llvm::StringRef GetStopShowColumnAnsiPrefix() const;
-
   llvm::StringRef GetStopShowColumnAnsiSuffix() const;
 
   uint32_t GetStopSourceLineCount(bool before) const;
+  uint32_t GetDisassemblyLineCount() const;
 
-  StopDisassemblyType GetStopDisassemblyDisplay() const;
+  enum StopDisassemblyType {
+    eStopDisassemblyTypeNever = 0,
+    eStopDisassemblyTypeNoDebugInfo,
+    eStopDisassemblyTypeNoSource,
+    eStopDisassemblyTypeAlways
+  };
 
-  uint32_t GetDisassemblyLineCount() const;
+  StopDisassemblyType GetStopDisassemblyDisplay() const;
+  uint32_t GetStopDisassemblyMaxSize() const;
 
   llvm::StringRef GetStopShowLineMarkerAnsiPrefix() const;
-
   llvm::StringRef GetStopShowLineMarkerAnsiSuffix() const;
 
-  bool GetAutoOneLineSummaries() const;
-
   bool GetAutoIndent() const;
-
   bool SetAutoIndent(bool b);
 
   bool GetPrintDecls() const;
-
   bool SetPrintDecls(bool b);
 
-  uint32_t GetTabSize() const;
+  bool GetNotifyVoid() const;
 
+  lldb::DWIMPrintVerbosity GetDWIMPrintVerbosity() const;
+
+  uint32_t GetTabSize() const;
   bool SetTabSize(uint32_t tab_size);
 
-  lldb::DWIMPrintVerbosity GetDWIMPrintVerbosity() const;
+  bool GetAutoConfirm() const;
 
   bool GetEscapeNonPrintables() const;
 
-  bool GetNotifyVoid() const;
+  bool GetAutoOneLineSummaries() const;
+  /// @}
 
   ConstString GetInstanceName() { return m_instance_name; }
 
   bool LoadPlugin(const FileSpec &spec, Status &error);
 
   void RunIOHandlers();
 
   bool IsForwardingEvents();
 
   void EnableForwardEvents(const lldb::ListenerSP &listener_sp);
 
   void CancelForwardEvents(const lldb::ListenerSP &listener_sp);
 
   bool IsHandlingEvents() const { return m_event_handler_thread.IsJoinable(); }
 
   Status RunREPL(lldb::LanguageType language, const char *repl_options);
-  
   /// Interruption in LLDB:
-  /// 
+  ///
   /// This is a voluntary interruption mechanism, not preemptive.  Parts of lldb
-  /// that do work that can be safely interrupted call 
+  /// that do work that can be safely interrupted call
   /// Debugger::InterruptRequested and if that returns true, they should return
   /// at a safe point, shortcutting the rest of the work they were to do.
-  ///  
-  /// lldb clients can both offer a CommandInterpreter (through 
+  ///
+  /// lldb clients can both offer a CommandInterpreter (through
   /// RunCommandInterpreter) and use the SB API's for their own purposes, so it
   /// is convenient to separate "interrupting the CommandInterpreter execution"
-  /// and interrupting the work it is doing with the SB API's.  So there are two 
-  /// ways to cause an interrupt: 
+  /// and interrupting the work it is doing with the SB API's.  So there are two
+  /// ways to cause an interrupt:
   ///   * CommandInterpreter::InterruptCommand: Interrupts the command currently
   ///     running in the command interpreter IOHandler thread
   ///   * Debugger::RequestInterrupt: Interrupts are active on anything but the
   ///     CommandInterpreter thread till CancelInterruptRequest is called.
   ///
   /// Since the two checks are mutually exclusive, however, it's also convenient
   /// to have just one function to check the interrupt state.
 
 
   /// Bump the "interrupt requested" count on the debugger to support
   /// cooperative interruption.  If this is non-zero, InterruptRequested will
   /// return true.  Interruptible operations are expected to query the
   /// InterruptRequested API periodically, and interrupt what they were doing
   /// if it returns \b true.
   ///
   void RequestInterrupt();
-  
   /// Decrement the "interrupt requested" counter.
   void CancelInterruptRequest();
-  
   /// This is the correct way to query the state of Interruption.
-  /// If you are on the RunCommandInterpreter thread, it will check the 
-  /// command interpreter state, and if it is on another thread it will 
+  /// If you are on the RunCommandInterpreter thread, it will check the
+  /// command interpreter state, and if it is on another thread it will
   /// check the debugger Interrupt Request state.
   ///
   /// \return
   ///  A boolean value, if \b true an interruptible operation should interrupt
   ///  itself.
   bool InterruptRequested();
 
   // This is for use in the command interpreter, when you either want the
protected:
 
   bool PopIOHandler(const lldb::IOHandlerSP &reader_sp);
 
   bool HasIOHandlerThread() const;
 
   bool StartIOHandlerThread();
 
   void StopIOHandlerThread();
-  
   // Sets the IOHandler thread to the new_thread, and returns
   // the previous IOHandler thread.
   HostThread SetIOHandlerThread(HostThread &new_thread);
 
   void JoinIOHandlerThread();
-  
   bool IsIOHandlerThreadCurrentThread() const;
 
   lldb::thread_result_t IOHandlerThread();
 
   lldb::thread_result_t DefaultEventHandler();
 
   void HandleBreakpointEvent(const lldb::EventSP &event_sp);