Enable AUTOBRIEF in doxygen configuration.

This brings the LLDB configuration closer to LLVM's and removes visual
clutter in the source code by removing the @brief commands from
comments.

This patch also reflows the paragraphs in all doxygen comments.

See also https://reviews.llvm.org/D46290.

Differential Revision: https://reviews.llvm.org/D46321

llvm-svn: 331373

12 files changed, 199 insertions, 216 deletions

diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h
index c0e6c0358a2..859a1dfa5f7 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h
@@ -18,18 +18,17 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ASTResultSynthesizer ASTResultSynthesizer.h
-/// "lldb/Expression/ASTResultSynthesizer.h"
-/// @brief Adds a result variable declaration to the ASTs for an expression.
+/// "lldb/Expression/ASTResultSynthesizer.h" Adds a result variable
+/// declaration to the ASTs for an expression.
 ///
 /// Users expect the expression "i + 3" to return a result, even if a result
 /// variable wasn't specifically declared.  To fulfil this requirement, LLDB
-/// adds
-/// a result variable to the expression, transforming it to
-/// "int $__lldb_expr_result = i + 3."  The IR transformers ensure that the
+/// adds a result variable to the expression, transforming it to "int
+/// $__lldb_expr_result = i + 3."  The IR transformers ensure that the
 /// resulting variable is mapped to the right piece of memory.
-/// ASTResultSynthesizer's job is to add the variable and its initialization to
-/// the ASTs for the expression, and it does so by acting as a SemaConsumer for
-/// Clang.
+/// ASTResultSynthesizer's job is to add the variable and its initialization
+/// to the ASTs for the expression, and it does so by acting as a SemaConsumer
+/// for Clang.
 //----------------------------------------------------------------------
 class ASTResultSynthesizer : public clang::SemaConsumer {
 public:
@@ -68,8 +67,8 @@ public:
   void Initialize(clang::ASTContext &Context) override;
 
   //----------------------------------------------------------------------
-  /// Examine a list of Decls to find the function $__lldb_expr and
-  /// transform its code
+  /// Examine a list of Decls to find the function $__lldb_expr and transform
+  /// its code
   ///
   /// @param[in] D
   ///     The list of Decls to search.  These may contain LinkageSpecDecls,
@@ -124,8 +123,8 @@ public:
 
 private:
   //----------------------------------------------------------------------
-  /// Hunt the given Decl for FunctionDecls named $__lldb_expr, recursing
-  /// as necessary through LinkageSpecDecls, and calling SynthesizeResult on
+  /// Hunt the given Decl for FunctionDecls named $__lldb_expr, recursing as
+  /// necessary through LinkageSpecDecls, and calling SynthesizeResult on
   /// anything that was found
   ///
   /// @param[in] D
@@ -164,8 +163,8 @@ private:
   bool SynthesizeBodyResult(clang::CompoundStmt *Body, clang::DeclContext *DC);
 
   //----------------------------------------------------------------------
-  /// Given a DeclContext for a function or method, find all types
-  /// declared in the context and record any persistent types found.
+  /// Given a DeclContext for a function or method, find all types declared in
+  /// the context and record any persistent types found.
   ///
   /// @param[in] FunDeclCtx
   ///     The context for the function to process.
@@ -173,8 +172,8 @@ private:
   void RecordPersistentTypes(clang::DeclContext *FunDeclCtx);
 
   //----------------------------------------------------------------------
-  /// Given a TypeDecl, if it declares a type whose name starts with a
-  /// dollar sign, register it as a pointer type in the target's scratch
+  /// Given a TypeDecl, if it declares a type whose name starts with a dollar
+  /// sign, register it as a pointer type in the target's scratch
   /// AST context.
   ///
   /// @param[in] Body
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h b/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h
index 63e3161cae8..65f4b00a865 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h
@@ -20,20 +20,19 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ASTStructExtractor ASTStructExtractor.h
-/// "lldb/Expression/ASTStructExtractor.h"
-/// @brief Extracts and describes the argument structure for a wrapped function.
+/// "lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument
+/// structure for a wrapped function.
 ///
 /// This pass integrates with ClangFunctionCaller, which calls functions with
-/// custom
-/// sets of arguments.  To avoid having to implement the full calling convention
-/// for the target's architecture, ClangFunctionCaller writes a simple wrapper
-/// function that takes a pointer to an argument structure that contains room
-/// for the address of the function to be called, the values of all its
-/// arguments, and room for the function's return value.
+/// custom sets of arguments.  To avoid having to implement the full calling
+/// convention for the target's architecture, ClangFunctionCaller writes a
+/// simple wrapper function that takes a pointer to an argument structure that
+/// contains room for the address of the function to be called, the values of
+/// all its arguments, and room for the function's return value.
 ///
-/// The definition of this struct is itself in the body of the wrapper function,
-/// so Clang does the structure layout itself.  ASTStructExtractor reads through
-/// the AST for the wrapper function and finds the struct.
+/// The definition of this struct is itself in the body of the wrapper
+/// function, so Clang does the structure layout itself.  ASTStructExtractor
+/// reads through the AST for the wrapper function and finds the struct.
 //----------------------------------------------------------------------
 class ASTStructExtractor : public clang::SemaConsumer {
 public:
@@ -73,8 +72,8 @@ public:
   void Initialize(clang::ASTContext &Context) override;
 
   //----------------------------------------------------------------------
-  /// Examine a list of Decls to find the function $__lldb_expr and
-  /// transform its code
+  /// Examine a list of Decls to find the function $__lldb_expr and transform
+  /// its code
   ///
   /// @param[in] D
   ///     The list of Decls to search.  These may contain LinkageSpecDecls,
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h
index 6f72ad92dc8..a42422b0f97 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h
@@ -25,14 +25,13 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ClangASTSource ClangASTSource.h "lldb/Expression/ClangASTSource.h"
-/// @brief Provider for named objects defined in the debug info for Clang
+/// Provider for named objects defined in the debug info for Clang
 ///
-/// As Clang parses an expression, it may encounter names that are not
-/// defined inside the expression, including variables, functions, and
-/// types.  Clang knows the name it is looking for, but nothing else.
-/// The ExternalSemaSource class provides Decls (VarDecl, FunDecl, TypeDecl)
-/// to Clang for these names, consulting the ClangExpressionDeclMap to do
-/// the actual lookups.
+/// As Clang parses an expression, it may encounter names that are not defined
+/// inside the expression, including variables, functions, and types.  Clang
+/// knows the name it is looking for, but nothing else. The ExternalSemaSource
+/// class provides Decls (VarDecl, FunDecl, TypeDecl) to Clang for these
+/// names, consulting the ClangExpressionDeclMap to do the actual lookups.
 //----------------------------------------------------------------------
 class ClangASTSource : public ClangExternalASTSourceCommon,
                        public ClangASTImporter::MapCompleter {
@@ -78,8 +77,8 @@ public:
   //------------------------------------------------------------------
   /// Look up all Decls that match a particular name.  Only handles
   /// Identifiers and DeclContexts that are either NamespaceDecls or
-  /// TranslationUnitDecls.  Calls SetExternalVisibleDeclsForName with
-  /// the result.
+  /// TranslationUnitDecls.  Calls SetExternalVisibleDeclsForName with the
+  /// result.
   ///
   /// The work for this function is done by
   /// void FindExternalVisibleDecls (NameSearchContext &);
@@ -173,8 +172,8 @@ public:
 
   //------------------------------------------------------------------
   /// Called on entering a translation unit.  Tells Clang by calling
-  /// setHasExternalVisibleStorage() and setHasExternalLexicalStorage()
-  /// that this object has something to say about undefined names.
+  /// setHasExternalVisibleStorage() and setHasExternalLexicalStorage() that
+  /// this object has something to say about undefined names.
   ///
   /// @param[in] ASTConsumer
   ///     Unused.
@@ -186,8 +185,8 @@ public:
   //
 
   //------------------------------------------------------------------
-  /// Look up the modules containing a given namespace and put the
-  /// appropriate entries in the namespace map.
+  /// Look up the modules containing a given namespace and put the appropriate
+  /// entries in the namespace map.
   ///
   /// @param[in] namespace_map
   ///     The map to be completed.
@@ -231,11 +230,10 @@ public:
 
   //----------------------------------------------------------------------
   /// @class ClangASTSourceProxy ClangASTSource.h
-  /// "lldb/Expression/ClangASTSource.h"
-  /// @brief Proxy for ClangASTSource
+  /// "lldb/Expression/ClangASTSource.h" Proxy for ClangASTSource
   ///
-  /// Clang AST contexts like to own their AST sources, so this is a
-  /// state-free proxy object.
+  /// Clang AST contexts like to own their AST sources, so this is a state-
+  /// free proxy object.
   //----------------------------------------------------------------------
   class ClangASTSourceProxy : public ClangExternalASTSourceCommon {
   public:
@@ -298,8 +296,8 @@ public:
 
 protected:
   //------------------------------------------------------------------
-  /// Look for the complete version of an Objective-C interface, and
-  /// return it if found.
+  /// Look for the complete version of an Objective-C interface, and return it
+  /// if found.
   ///
   /// @param[in] interface_decl
   ///     An ObjCInterfaceDecl that may not be the complete one.
@@ -312,8 +310,8 @@ protected:
   GetCompleteObjCInterface(const clang::ObjCInterfaceDecl *interface_decl);
 
   //------------------------------------------------------------------
-  /// Find all entities matching a given name in a given module,
-  /// using a NameSearchContext to make Decls for them.
+  /// Find all entities matching a given name in a given module, using a
+  /// NameSearchContext to make Decls for them.
   ///
   /// @param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
@@ -474,8 +472,9 @@ protected:
 };
 
 //----------------------------------------------------------------------
-/// @class NameSearchContext ClangASTSource.h "lldb/Expression/ClangASTSource.h"
-/// @brief Container for all objects relevant to a single name lookup
+/// @class NameSearchContext ClangASTSource.h
+/// "lldb/Expression/ClangASTSource.h" Container for all objects relevant to a
+/// single name lookup
 ///
 /// LLDB needs to create Decls for entities it finds.  This class communicates
 /// what name is being searched for and provides helper functions to construct
@@ -532,8 +531,8 @@ struct NameSearchContext {
   }
 
   //------------------------------------------------------------------
-  /// Create a VarDecl with the name being searched for and the provided
-  /// type and register it in the right places.
+  /// Create a VarDecl with the name being searched for and the provided type
+  /// and register it in the right places.
   ///
   /// @param[in] type
   ///     The opaque QualType for the VarDecl being registered.
@@ -541,8 +540,8 @@ struct NameSearchContext {
   clang::NamedDecl *AddVarDecl(const CompilerType &type);
 
   //------------------------------------------------------------------
-  /// Create a FunDecl with the name being searched for and the provided
-  /// type and register it in the right places.
+  /// Create a FunDecl with the name being searched for and the provided type
+  /// and register it in the right places.
   ///
   /// @param[in] type
   ///     The opaque QualType for the FunDecl being registered.
@@ -553,15 +552,14 @@ struct NameSearchContext {
   clang::NamedDecl *AddFunDecl(const CompilerType &type, bool extern_c = false);
 
   //------------------------------------------------------------------
-  /// Create a FunDecl with the name being searched for and generic
-  /// type (i.e. intptr_t NAME_GOES_HERE(...)) and register it in the
-  /// right places.
+  /// Create a FunDecl with the name being searched for and generic type (i.e.
+  /// intptr_t NAME_GOES_HERE(...)) and register it in the right places.
   //------------------------------------------------------------------
   clang::NamedDecl *AddGenericFunDecl();
 
   //------------------------------------------------------------------
-  /// Create a TypeDecl with the name being searched for and the provided
-  /// type and register it in the right places.
+  /// Create a TypeDecl with the name being searched for and the provided type
+  /// and register it in the right places.
   ///
   /// @param[in] compiler_type
   ///     The opaque QualType for the TypeDecl being registered.
@@ -569,8 +567,8 @@ struct NameSearchContext {
   clang::NamedDecl *AddTypeDecl(const CompilerType &compiler_type);
 
   //------------------------------------------------------------------
-  /// Add Decls from the provided DeclContextLookupResult to the list
-  /// of results.
+  /// Add Decls from the provided DeclContextLookupResult to the list of
+  /// results.
   ///
   /// @param[in] result
   ///     The DeclContextLookupResult, usually returned as the result
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
index d163ad4f7e2..b6738793019 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
@@ -36,29 +36,28 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ClangExpressionDeclMap ClangExpressionDeclMap.h
-/// "lldb/Expression/ClangExpressionDeclMap.h"
-/// @brief Manages named entities that are defined in LLDB's debug information.
+/// "lldb/Expression/ClangExpressionDeclMap.h" Manages named entities that are
+/// defined in LLDB's debug information.
 ///
 /// The Clang parser uses the ClangASTSource as an interface to request named
 /// entities from outside an expression.  The ClangASTSource reports back,
-/// listing
-/// all possible objects corresponding to a particular name.  But it in turn
-/// relies on ClangExpressionDeclMap, which performs several important
+/// listing all possible objects corresponding to a particular name.  But it
+/// in turn relies on ClangExpressionDeclMap, which performs several important
 /// functions.
 ///
-/// First, it records what variables and functions were looked up and what Decls
-/// were returned for them.
+/// First, it records what variables and functions were looked up and what
+/// Decls were returned for them.
 ///
 /// Second, it constructs a struct on behalf of IRForTarget, recording which
-/// variables should be placed where and relaying this information back so that
-/// IRForTarget can generate context-independent code.
+/// variables should be placed where and relaying this information back so
+/// that IRForTarget can generate context-independent code.
 ///
 /// Third, it "materializes" this struct on behalf of the expression command,
 /// finding the current values of each variable and placing them into the
 /// struct so that it can be passed to the JITted version of the IR.
 ///
-/// Fourth and finally, it "dematerializes" the struct after the JITted code has
-/// has executed, placing the new values back where it found the old ones.
+/// Fourth and finally, it "dematerializes" the struct after the JITted code
+/// has has executed, placing the new values back where it found the old ones.
 //----------------------------------------------------------------------
 class ClangExpressionDeclMap : public ClangASTSource {
 public:
@@ -169,8 +168,8 @@ public:
                         lldb::offset_t alignment);
 
   //------------------------------------------------------------------
-  /// [Used by IRForTarget] Finalize the struct, laying out the position
-  /// of each object in it.
+  /// [Used by IRForTarget] Finalize the struct, laying out the position of
+  /// each object in it.
   ///
   /// @return
   ///     True on success; false otherwise.
@@ -178,8 +177,8 @@ public:
   bool DoStructLayout();
 
   //------------------------------------------------------------------
-  /// [Used by IRForTarget] Get general information about the laid-out
-  /// struct after DoStructLayout() has been called.
+  /// [Used by IRForTarget] Get general information about the laid-out struct
+  /// after DoStructLayout() has been called.
   ///
   /// @param[out] num_elements
   ///     The number of elements in the struct.
@@ -197,8 +196,8 @@ public:
                      lldb::offset_t &alignment);
 
   //------------------------------------------------------------------
-  /// [Used by IRForTarget] Get specific information about one field
-  /// of the laid-out struct after DoStructLayout() has been called.
+  /// [Used by IRForTarget] Get specific information about one field of the
+  /// laid-out struct after DoStructLayout() has been called.
   ///
   /// @param[out] decl
   ///     The parsed Decl for the field, as generated by ClangASTSource
@@ -232,8 +231,7 @@ public:
                         uint32_t index);
 
   //------------------------------------------------------------------
-  /// [Used by IRForTarget] Get information about a function given its
-  /// Decl.
+  /// [Used by IRForTarget] Get information about a function given its Decl.
   ///
   /// @param[in] decl
   ///     The parsed Decl for the Function, as generated by ClangASTSource
@@ -248,8 +246,8 @@ public:
   bool GetFunctionInfo(const clang::NamedDecl *decl, uint64_t &ptr);
 
   //------------------------------------------------------------------
-  /// [Used by IRForTarget] Get the address of a symbol given nothing
-  /// but its name.
+  /// [Used by IRForTarget] Get the address of a symbol given nothing but its
+  /// name.
   ///
   /// @param[in] target
   ///     The target to find the symbol in.  If not provided,
@@ -303,8 +301,8 @@ public:
   TargetInfo GetTargetInfo();
 
   //------------------------------------------------------------------
-  /// [Used by ClangASTSource] Find all entities matching a given name,
-  /// using a NameSearchContext to make Decls for them.
+  /// [Used by ClangASTSource] Find all entities matching a given name, using
+  /// a NameSearchContext to make Decls for them.
   ///
   /// @param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
@@ -442,14 +440,13 @@ private:
   void DisableStructVars() { m_struct_vars.reset(); }
 
   //----------------------------------------------------------------------
-  /// Get this parser's ID for use in extracting parser- and JIT-specific
-  /// data from persistent variables.
+  /// Get this parser's ID for use in extracting parser- and JIT-specific data
+  /// from persistent variables.
   //----------------------------------------------------------------------
   uint64_t GetParserID() { return (uint64_t) this; }
 
   //------------------------------------------------------------------
-  /// Given a target, find a variable that matches the given name and
-  /// type.
+  /// Given a target, find a variable that matches the given name and type.
   ///
   /// @param[in] target
   ///     The target to use as a basis for finding the variable.
@@ -477,8 +474,8 @@ private:
                                       TypeFromUser *type = NULL);
 
   //------------------------------------------------------------------
-  /// Get the value of a variable in a given execution context and return
-  /// the associated Types if needed.
+  /// Get the value of a variable in a given execution context and return the
+  /// associated Types if needed.
   ///
   /// @param[in] var
   ///     The variable to evaluate.
@@ -524,8 +521,8 @@ private:
                       lldb::ValueObjectSP valobj, unsigned int current_id);
 
   //------------------------------------------------------------------
-  /// Use the NameSearchContext to generate a Decl for the given
-  /// persistent variable, and put it in the list of found entities.
+  /// Use the NameSearchContext to generate a Decl for the given persistent
+  /// variable, and put it in the list of found entities.
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
@@ -542,9 +539,8 @@ private:
                       unsigned int current_id);
 
   //------------------------------------------------------------------
-  /// Use the NameSearchContext to generate a Decl for the given LLDB
-  /// symbol (treated as a variable), and put it in the list of found
-  /// entities.
+  /// Use the NameSearchContext to generate a Decl for the given LLDB symbol
+  /// (treated as a variable), and put it in the list of found entities.
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
@@ -556,9 +552,9 @@ private:
                              unsigned int current_id);
 
   //------------------------------------------------------------------
-  /// Use the NameSearchContext to generate a Decl for the given
-  /// function.  (Functions are not placed in the Tuple list.)  Can
-  /// handle both fully typed functions and generic functions.
+  /// Use the NameSearchContext to generate a Decl for the given function.
+  /// (Functions are not placed in the Tuple list.)  Can handle both fully
+  /// typed functions and generic functions.
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
@@ -575,8 +571,7 @@ private:
                       unsigned int current_id);
 
   //------------------------------------------------------------------
-  /// Use the NameSearchContext to generate a Decl for the given
-  /// register.
+  /// Use the NameSearchContext to generate a Decl for the given register.
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
@@ -588,8 +583,8 @@ private:
                       unsigned int current_id);
 
   //------------------------------------------------------------------
-  /// Use the NameSearchContext to generate a Decl for the given
-  /// type.  (Types are not placed in the Tuple list.)
+  /// Use the NameSearchContext to generate a Decl for the given type.  (Types
+  /// are not placed in the Tuple list.)
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
@@ -601,8 +596,8 @@ private:
                   unsigned int current_id);
 
   //------------------------------------------------------------------
-  /// Generate a Decl for "*this" and add a member function declaration
-  /// to it for the expression, then report it.
+  /// Generate a Decl for "*this" and add a member function declaration to it
+  /// for the expression, then report it.
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h
index 41f290f2e12..4058ec1270b 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h
@@ -26,14 +26,14 @@ class IRExecutionUnit;
 
 //----------------------------------------------------------------------
 /// @class ClangExpressionParser ClangExpressionParser.h
-/// "lldb/Expression/ClangExpressionParser.h"
-/// @brief Encapsulates an instance of Clang that can parse expressions.
+/// "lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of
+/// Clang that can parse expressions.
 ///
 /// ClangExpressionParser is responsible for preparing an instance of
 /// ClangExpression for execution.  ClangExpressionParser uses ClangExpression
 /// as a glorified parameter list, performing the required parsing and
-/// conversion to formats (DWARF bytecode, or JIT compiled machine code)
-/// that can be executed.
+/// conversion to formats (DWARF bytecode, or JIT compiled machine code) that
+/// can be executed.
 //----------------------------------------------------------------------
 class ClangExpressionParser : public ExpressionParser {
 public:
@@ -59,8 +59,8 @@ public:
   ~ClangExpressionParser() override;
 
   //------------------------------------------------------------------
-  /// Parse a single expression and convert it to IR using Clang.  Don't
-  /// wrap the expression in anything at all.
+  /// Parse a single expression and convert it to IR using Clang.  Don't wrap
+  /// the expression in anything at all.
   ///
   /// @param[in] diagnostic_manager
   ///     The diagnostic manager to report errors to.
@@ -74,8 +74,8 @@ public:
   bool RewriteExpression(DiagnosticManager &diagnostic_manager) override;
 
   //------------------------------------------------------------------
-  /// Ready an already-parsed expression for execution, possibly
-  /// evaluating it statically.
+  /// Ready an already-parsed expression for execution, possibly evaluating it
+  /// statically.
   ///
   /// @param[out] func_addr
   ///     The address to which the function has been written.
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h
index baa80d7ba0d..7d5ced5b470 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h
@@ -41,27 +41,25 @@ class ValueObjectConstResult;
 
 //----------------------------------------------------------------------
 /// @class ClangExpressionVariable ClangExpressionVariable.h
-/// "lldb/Expression/ClangExpressionVariable.h"
-/// @brief Encapsulates one variable for the expression parser.
+/// "lldb/Expression/ClangExpressionVariable.h" Encapsulates one variable for
+/// the expression parser.
 ///
 /// The expression parser uses variables in three different contexts:
 ///
-/// First, it stores persistent variables along with the process for use
-/// in expressions.  These persistent variables contain their own data
-/// and are typed.
+/// First, it stores persistent variables along with the process for use in
+/// expressions.  These persistent variables contain their own data and are
+/// typed.
 ///
-/// Second, in an interpreted expression, it stores the local variables
-/// for the expression along with the expression.  These variables
-/// contain their own data and are typed.
+/// Second, in an interpreted expression, it stores the local variables for
+/// the expression along with the expression.  These variables contain their
+/// own data and are typed.
 ///
-/// Third, in a JIT-compiled expression, it stores the variables that
-/// the expression needs to have materialized and dematerialized at each
-/// execution.  These do not contain their own data but are named and
-/// typed.
+/// Third, in a JIT-compiled expression, it stores the variables that the
+/// expression needs to have materialized and dematerialized at each
+/// execution.  These do not contain their own data but are named and typed.
 ///
-/// This class supports all of these use cases using simple type
-/// polymorphism, and provides necessary support methods.  Its interface
-/// is RTTI-neutral.
+/// This class supports all of these use cases using simple type polymorphism,
+/// and provides necessary support methods.  Its interface is RTTI-neutral.
 //----------------------------------------------------------------------
 class ClangExpressionVariable : public ExpressionVariable {
 public:
@@ -79,8 +77,8 @@ public:
                           lldb::ByteOrder byte_order, uint32_t addr_byte_size);
 
   //----------------------------------------------------------------------
-  /// Utility functions for dealing with ExpressionVariableLists in
-  /// Clang-specific ways
+  /// Utility functions for dealing with ExpressionVariableLists in Clang-
+  /// specific ways
   //----------------------------------------------------------------------
 
   //----------------------------------------------------------------------
@@ -112,9 +110,9 @@ public:
   }
 
   //----------------------------------------------------------------------
-  /// If the variable contains its own data, make a Value point at it.
-  /// If \a exe_ctx in not NULL, the value will be resolved in with
-  /// that execution context.
+  /// If the variable contains its own data, make a Value point at it. If \a
+  /// exe_ctx in not NULL, the value will be resolved in with that execution
+  /// context.
   ///
   /// @param[in] value
   ///     The value to point at the data.
@@ -156,8 +154,8 @@ private:
 
 public:
   //----------------------------------------------------------------------
-  /// Make this variable usable by the parser by allocating space for
-  /// parser-specific variables
+  /// Make this variable usable by the parser by allocating space for parser-
+  /// specific variables
   //----------------------------------------------------------------------
   void EnableParserVars(uint64_t parser_id) {
     m_parser_vars.insert(std::make_pair(parser_id, ParserVars()));
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h
index 0596d8fde7b..438cf0c713d 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h
@@ -31,8 +31,8 @@ class ClangExpressionParser;
 
 //----------------------------------------------------------------------
 /// @class ClangFunctionCaller ClangFunctionCaller.h
-/// "lldb/Expression/ClangFunctionCaller.h"
-/// @brief Encapsulates a function that can be called.
+/// "lldb/Expression/ClangFunctionCaller.h" Encapsulates a function that can
+/// be called.
 ///
 /// A given ClangFunctionCaller object can handle a single function signature.
 /// Once constructed, it can set up any number of concurrent calls to
@@ -56,8 +56,8 @@ class ClangExpressionParser;
 /// If you need to call the function on the thread plan stack, you can also
 /// call InsertFunction() followed by GetThreadPlanToCallFunction().
 ///
-/// Any of the methods that take arg_addr_ptr or arg_addr_ref can be passed
-/// a pointer set to LLDB_INVALID_ADDRESS and new structure will be allocated
+/// Any of the methods that take arg_addr_ptr or arg_addr_ref can be passed a
+/// pointer set to LLDB_INVALID_ADDRESS and new structure will be allocated
 /// and its address returned in that variable.
 ///
 /// Any of the methods that take arg_addr_ptr can be passed NULL, and the
@@ -79,8 +79,8 @@ class ClangFunctionCaller : public FunctionCaller {
     ClangExpressionDeclMap *DeclMap() override { return NULL; }
 
     //------------------------------------------------------------------
-    /// Return the object that the parser should allow to access ASTs.
-    /// May be NULL if the ASTs do not need to be transformed.
+    /// Return the object that the parser should allow to access ASTs. May be
+    /// NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h
index 1432fae711e..59126974616 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h
@@ -25,9 +25,8 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ClangPersistentVariables ClangPersistentVariables.h
-/// "lldb/Expression/ClangPersistentVariables.h"
-/// @brief Manages persistent values that need to be preserved between
-/// expression invocations.
+/// "lldb/Expression/ClangPersistentVariables.h" Manages persistent values
+/// that need to be preserved between expression invocations.
 ///
 /// A list of variables that can be accessed and updated by any expression.  See
 /// ClangPersistentVariable for more discussion.  Also provides an increasing,
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h
index 16d4af8b167..434168e2ce5 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h
@@ -35,13 +35,13 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ClangUserExpression ClangUserExpression.h
-/// "lldb/Expression/ClangUserExpression.h"
-/// @brief Encapsulates a single expression for use with Clang
+/// "lldb/Expression/ClangUserExpression.h" Encapsulates a single expression
+/// for use with Clang
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  ClangUserExpression encapsulates
-/// the objects needed to parse and interpret or JIT an expression.  It
-/// uses the Clang parser to produce LLVM IR from the expression.
+/// the objects needed to parse and interpret or JIT an expression.  It uses
+/// the Clang parser to produce LLVM IR from the expression.
 //----------------------------------------------------------------------
 class ClangUserExpression : public LLVMUserExpression {
 public:
@@ -69,8 +69,8 @@ public:
                       bool keep_result_in_memory);
 
     //------------------------------------------------------------------
-    /// Return the object that the parser should allow to access ASTs.
-    /// May be NULL if the ASTs do not need to be transformed.
+    /// Return the object that the parser should allow to access ASTs. May be
+    /// NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h
index 80577199b81..a897a2b1708 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h
@@ -29,15 +29,15 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class ClangUtilityFunction ClangUtilityFunction.h
-/// "lldb/Expression/ClangUtilityFunction.h"
-/// @brief Encapsulates a single expression for use with Clang
+/// "lldb/Expression/ClangUtilityFunction.h" Encapsulates a single expression
+/// for use with Clang
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  ClangUtilityFunction encapsulates
 /// a self-contained function meant to be used from other code.  Utility
 /// functions can perform error-checking for ClangUserExpressions, or can
-/// simply provide a way to push a function into the target for the debugger to
-/// call later on.
+/// simply provide a way to push a function into the target for the debugger
+/// to call later on.
 //----------------------------------------------------------------------
 class ClangUtilityFunction : public UtilityFunction {
 public:
@@ -60,8 +60,8 @@ public:
     void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory);
 
     //------------------------------------------------------------------
-    /// Return the object that the parser should allow to access ASTs.
-    /// May be NULL if the ASTs do not need to be transformed.
+    /// Return the object that the parser should allow to access ASTs. May be
+    /// NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h
index 93ce8aa44eb..c6c44b46023 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h
@@ -47,12 +47,11 @@ class IRMemoryMap;
 
 //----------------------------------------------------------------------
 /// @class IRForTarget IRForTarget.h "lldb/Expression/IRForTarget.h"
-/// @brief Transforms the IR for a function to run in the target
+/// Transforms the IR for a function to run in the target
 ///
-/// Once an expression has been parsed and converted to IR, it can run
-/// in two contexts: interpreted by LLDB as a DWARF location expression,
-/// or compiled by the JIT and inserted into the target process for
-/// execution.
+/// Once an expression has been parsed and converted to IR, it can run in two
+/// contexts: interpreted by LLDB as a DWARF location expression, or compiled
+/// by the JIT and inserted into the target process for execution.
 ///
 /// IRForTarget makes the second possible, by applying a series of
 /// transformations to the IR which make it relocatable.  These
@@ -126,8 +125,7 @@ public:
   //------------------------------------------------------------------
   /// Interface stub
   ///
-  /// Implementation of the llvm::ModulePass::assignPassManager()
-  /// function.
+  /// Implementation of the llvm::ModulePass::assignPassManager() function.
   //------------------------------------------------------------------
   void assignPassManager(llvm::PMStack &pass_mgr_stack,
                          llvm::PassManagerType pass_mgr_type =
@@ -179,8 +177,8 @@ private:
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
-  /// Get the address of a function, and a location to put the complete
-  /// Value of the function if one is available.
+  /// Get the address of a function, and a location to put the complete Value
+  /// of the function if one is available.
   ///
   /// @param[in] function
   ///     The function to find the location of.
@@ -204,13 +202,13 @@ private:
 
   //------------------------------------------------------------------
   /// A function-level pass to take the generated global value
-  /// $__lldb_expr_result and make it into a persistent variable.
-  /// Also see ASTResultSynthesizer.
+  /// $__lldb_expr_result and make it into a persistent variable. Also see
+  /// ASTResultSynthesizer.
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
-  /// Find the NamedDecl corresponding to a Value.  This interface is
-  /// exposed for the IR interpreter.
+  /// Find the NamedDecl corresponding to a Value.  This interface is exposed
+  /// for the IR interpreter.
   ///
   /// @param[in] module
   ///     The module containing metadata to search
@@ -230,8 +228,8 @@ private:
 
   //------------------------------------------------------------------
   /// Set the constant result variable m_const_result to the provided
-  /// constant, assuming it can be evaluated.  The result variable
-  /// will be reset to NULL later if the expression has side effects.
+  /// constant, assuming it can be evaluated.  The result variable will be
+  /// reset to NULL later if the expression has side effects.
   ///
   /// @param[in] initializer
   ///     The constant initializer for the variable.
@@ -247,8 +245,8 @@ private:
                               lldb_private::TypeFromParser type);
 
   //------------------------------------------------------------------
-  /// If the IR represents a cast of a variable, set m_const_result
-  /// to the result of the cast.  The result variable will be reset to
+  /// If the IR represents a cast of a variable, set m_const_result to the
+  /// result of the cast.  The result variable will be reset to
   /// NULL latger if the expression has side effects.
   ///
   /// @param[in] type
@@ -301,10 +299,9 @@ private:
   /// rewrite them to use sel_registerName instead of statically allocated
   /// selectors.  The reason is that the selectors are created on the
   /// assumption that the Objective-C runtime will scan the appropriate
-  /// section and prepare them.  This doesn't happen when code is copied
-  /// into the target, though, and there's no easy way to induce the
-  /// runtime to scan them.  So instead we get our selectors from
-  /// sel_registerName.
+  /// section and prepare them.  This doesn't happen when code is copied into
+  /// the target, though, and there's no easy way to induce the runtime to
+  /// scan them.  So instead we get our selectors from sel_registerName.
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
@@ -359,13 +356,12 @@ private:
 
   //------------------------------------------------------------------
   /// A basic block-level pass to find all newly-declared persistent
-  /// variables and register them with the ClangExprDeclMap.  This
-  /// allows them to be materialized and dematerialized like normal
-  /// external variables.  Before transformation, these persistent
-  /// variables look like normal locals, so they have an allocation.
-  /// This pass excises these allocations and makes references look
-  /// like external references where they will be resolved -- like all
-  /// other external references -- by ResolveExternals().
+  /// variables and register them with the ClangExprDeclMap.  This allows them
+  /// to be materialized and dematerialized like normal external variables.
+  /// Before transformation, these persistent variables look like normal
+  /// locals, so they have an allocation. This pass excises these allocations
+  /// and makes references look like external references where they will be
+  /// resolved -- like all other external references -- by ResolveExternals().
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
@@ -389,15 +385,14 @@ private:
 
   //------------------------------------------------------------------
   /// A function-level pass to find all external variables and functions
-  /// used in the IR.  Each found external variable is added to the
-  /// struct, and each external function is resolved in place, its call
-  /// replaced with a call to a function pointer whose value is the
-  /// address of the function in the target process.
+  /// used in the IR.  Each found external variable is added to the struct,
+  /// and each external function is resolved in place, its call replaced with
+  /// a call to a function pointer whose value is the address of the function
+  /// in the target process.
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
-  /// Write an initializer to a memory array of assumed sufficient
-  /// size.
+  /// Write an initializer to a memory array of assumed sufficient size.
   ///
   /// @param[in] data
   ///     A pointer to the data to write to.
@@ -504,8 +499,8 @@ private:
   //------------------------------------------------------------------
   /// A basic block-level pass to excise guard variables from the code.
   /// The result for the function is passed through Clang as a static
-  /// variable.  Static variables normally have guard variables to
-  /// ensure that they are only initialized once.
+  /// variable.  Static variables normally have guard variables to ensure that
+  /// they are only initialized once.
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
@@ -529,9 +524,9 @@ private:
 
   //------------------------------------------------------------------
   /// A function-level pass to make all external variable references
-  /// point at the correct offsets from the void* passed into the
-  /// function.  ClangExpressionDeclMap::DoStructLayout() must be called
-  /// beforehand, so that the offsets are valid.
+  /// point at the correct offsets from the void* passed into the function.
+  /// ClangExpressionDeclMap::DoStructLayout() must be called beforehand, so
+  /// that the offsets are valid.
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
@@ -583,7 +578,8 @@ private:
 
   llvm::StoreInst *m_result_store; ///< If non-NULL, the store instruction that
                                    ///writes to the result variable.  If
-                                   /// m_has_side_effects is true, this is NULL.
+                                   /// m_has_side_effects is true, this is
+                                   /// NULL.
   bool m_result_is_pointer; ///< True if the function's result in the AST is a
                             ///pointer (see comments in
                             /// ASTResultSynthesizer::SynthesizeBodyResult)
@@ -594,18 +590,17 @@ private:
   /// location of the static allocation.
 
   //------------------------------------------------------------------
-  /// UnfoldConstant operates on a constant [Old] which has just been
-  /// replaced with a value [New].  We assume that new_value has
-  /// been properly placed early in the function, in front of the
-  /// first instruction in the entry basic block
-  /// [FirstEntryInstruction].
+  /// UnfoldConstant operates on a constant [Old] which has just been replaced
+  /// with a value [New].  We assume that new_value has been properly placed
+  /// early in the function, in front of the first instruction in the entry
+  /// basic block [FirstEntryInstruction].
   ///
-  /// UnfoldConstant reads through the uses of Old and replaces Old
-  /// in those uses with New.  Where those uses are constants, the
-  /// function generates new instructions to compute the result of the
-  /// new, non-constant expression and places them before
-  /// FirstEntryInstruction.  These instructions replace the constant
-  /// uses, so UnfoldConstant calls itself recursively for those.
+  /// UnfoldConstant reads through the uses of Old and replaces Old in those
+  /// uses with New.  Where those uses are constants, the function generates
+  /// new instructions to compute the result of the new, non-constant
+  /// expression and places them before FirstEntryInstruction.  These
+  /// instructions replace the constant uses, so UnfoldConstant calls itself
+  /// recursively for those.
   ///
   /// @param[in] llvm_function
   ///     The function currently being processed.
@@ -637,8 +632,8 @@ private:
                              lldb_private::Stream &error_stream);
 
   //------------------------------------------------------------------
-  /// Construct a reference to m_reloc_placeholder with a given type
-  /// and offset.  This typically happens after inserting data into
+  /// Construct a reference to m_reloc_placeholder with a given type and
+  /// offset.  This typically happens after inserting data into
   /// m_data_allocator.
   ///
   /// @param[in] type
@@ -653,8 +648,8 @@ private:
   llvm::Constant *BuildRelocation(llvm::Type *type, uint64_t offset);
 
   //------------------------------------------------------------------
-  /// Commit the allocation in m_data_allocator and use its final
-  /// location to replace m_reloc_placeholder.
+  /// Commit the allocation in m_data_allocator and use its final location to
+  /// replace m_reloc_placeholder.
   ///
   /// @param[in] module
   ///     The module that m_data_allocator resides in
diff --git a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h
index 5d55b296ed3..e2839da9bfd 100644
--- a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h
+++ b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h
@@ -50,12 +50,12 @@ private:
 
 //----------------------------------------------------------------------
 /// @class GoUserExpression GoUserExpression.h
-/// "lldb/Expression/GoUserExpression.h"
-/// @brief Encapsulates a single expression for use with Go
+/// "lldb/Expression/GoUserExpression.h" Encapsulates a single expression for
+/// use with Go
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
-/// and as a backend for the expr command.  GoUserExpression encapsulates
-/// the objects needed to parse and interpret an expression.
+/// and as a backend for the expr command.  GoUserExpression encapsulates the
+/// objects needed to parse and interpret an expression.
 //----------------------------------------------------------------------
 class GoUserExpression : public UserExpression {
 public: