Reflow paragraphs in comments.

This is intended as a clean up after the big clang-format commit
(r280751), which unfortunately resulted in many of the comment
paragraphs in LLDB being very hard to read.

FYI, the script I used was:

import textwrap
import commands
import os
import sys
import re
tmp = "%s.tmp"%sys.argv[1]
out = open(tmp, "w+")
with open(sys.argv[1], "r") as f:
  header = ""
  text = ""
  comment = re.compile(r'^( *//) ([^ ].*)$')
  special = re.compile(r'^((([A-Z]+[: ])|([0-9]+ )).*)|(.*;)$')
  for line in f:
      match = comment.match(line)
      if match and not special.match(match.group(2)):
          # skip intentionally short comments.
          if not text and len(match.group(2)) < 40:
              out.write(line)
              continue

          if text:
              text += " " + match.group(2)
          else:
              header = match.group(1)
              text = match.group(2)

          continue

      if text:
          filled = textwrap.wrap(text, width=(78-len(header)),
                                 break_long_words=False)
          for l in filled:
              out.write(header+" "+l+'\n')
              text = ""

      out.write(line)

os.rename(tmp, sys.argv[1])

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

llvm-svn: 331197

9 files changed, 146 insertions, 184 deletions

diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp
index 9e6a2f3acafe..524f9bd24f13 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp
@@ -226,8 +226,7 @@ bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
     return true;
 
   // In C++11, last_expr can be a LValueToRvalue implicit cast.  Strip that off
-  // if that's the
-  // case.
+  // if that's the case.
 
   do {
     ImplicitCastExpr *implicit_cast = dyn_cast<ImplicitCastExpr>(last_expr);
@@ -242,8 +241,8 @@ bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
   } while (0);
 
   // is_lvalue is used to record whether the expression returns an assignable
-  // Lvalue or an
-  // Rvalue.  This is relevant because they are handled differently.
+  // Lvalue or an Rvalue.  This is relevant because they are handled
+  // differently.
   //
   // For Lvalues
   //
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
index b929a052d413..c26b1a615a18 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
@@ -33,8 +33,8 @@ using namespace clang;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
-// Scoped class that will remove an active lexical decl from the set
-// when it goes out of scope.
+// Scoped class that will remove an active lexical decl from the set when it
+// goes out of scope.
 //------------------------------------------------------------------
 namespace {
 class ScopedLexicalDeclEraser {
@@ -141,8 +141,8 @@ ClangASTSource::~ClangASTSource() {
     m_ast_importer_sp->ForgetDestination(m_ast_context);
 
   // We are in the process of destruction, don't create clang ast context on
-  // demand
-  // by passing false to Target::GetScratchClangASTContext(create_on_demand).
+  // demand by passing false to
+  // Target::GetScratchClangASTContext(create_on_demand).
   ClangASTContext *scratch_clang_ast_context =
       m_target->GetScratchClangASTContext(false);
 
@@ -231,8 +231,8 @@ bool ClangASTSource::FindExternalVisibleDeclsByName(
   }
 
   if (!GetLookupsEnabled()) {
-    // Wait until we see a '$' at the start of a name before we start doing
-    // any lookups so we can avoid lookup up all of the builtin types.
+    // Wait until we see a '$' at the start of a name before we start doing any
+    // lookups so we can avoid lookup up all of the builtin types.
     if (!decl_name.empty() && decl_name[0] == '$') {
       SetLookupsEnabled(true);
     } else {
@@ -297,8 +297,8 @@ void ClangASTSource::CompleteType(TagDecl *tag_decl) {
   }
 
   if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
-    // We couldn't complete the type.  Maybe there's a definition
-    // somewhere else that can be completed.
+    // We couldn't complete the type.  Maybe there's a definition somewhere
+    // else that can be completed.
 
     if (log)
       log->Printf("      CTD[%u] Type could not be completed in the module in "
@@ -398,8 +398,8 @@ void ClangASTSource::CompleteType(TagDecl *tag_decl) {
             const_cast<TagDecl *>(tag_type->getDecl());
 
         // We have found a type by basename and we need to make sure the decl
-        // contexts
-        // are the same before we can try to complete this type with another
+        // contexts are the same before we can try to complete this type with
+        // another
         if (!ClangASTContext::DeclsAreEquivalent(tag_decl, candidate_tag_decl))
           continue;
 
@@ -1243,8 +1243,8 @@ void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) {
       break;
 
     // Fall back and check for methods in categories.  If we find methods this
-    // way, we need to check that they're actually in
-    // categories on the desired class.
+    // way, we need to check that they're actually in categories on the desired
+    // class.
 
     SymbolContextList candidate_sc_list;
 
@@ -1591,8 +1591,7 @@ void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) {
 
   do {
     // Check the runtime only if the debug information didn't have a complete
-    // interface
-    // and nothing was in the modules.
+    // interface and nothing was in the modules.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
@@ -1645,12 +1644,9 @@ static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
                             ClangASTSource &source) {
   // When importing fields into a new record, clang has a hard requirement that
   // fields be imported in field offset order.  Since they are stored in a
-  // DenseMap
-  // with a pointer as the key type, this means we cannot simply iterate over
-  // the
-  // map, as the order will be non-deterministic.  Instead we have to sort by
-  // the offset
-  // and then insert in sorted order.
+  // DenseMap with a pointer as the key type, this means we cannot simply
+  // iterate over the map, as the order will be non-deterministic.  Instead we
+  // have to sort by the offset and then insert in sorted order.
   typedef llvm::DenseMap<const D *, O> MapType;
   typedef typename MapType::value_type PairType;
   std::vector<PairType> sorted_items;
@@ -2051,9 +2047,8 @@ CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) {
 
   if (copied_qual_type.getAsOpaquePtr() &&
       copied_qual_type->getCanonicalTypeInternal().isNull())
-    // this shouldn't happen, but we're hardening because the AST importer seems
-    // to be generating bad types
-    // on occasion.
+    // this shouldn't happen, but we're hardening because the AST importer
+    // seems to be generating bad types on occasion.
     return CompilerType();
 
   return CompilerType(m_ast_context, copied_qual_type);
@@ -2156,8 +2151,8 @@ clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
       log->Printf("Function type wasn't a FunctionProtoType");
   }
 
-  // If this is an operator (e.g. operator new or operator==), only insert
-  // the declaration we inferred from the symbol if we can provide the correct
+  // If this is an operator (e.g. operator new or operator==), only insert the
+  // declaration we inferred from the symbol if we can provide the correct
   // number of arguments. We shouldn't really inject random decl(s) for
   // functions that are analyzed semantically in a special way, otherwise we
   // will crash in clang.
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
index 76f08dc426aa..5a970aadd4fd 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
@@ -213,8 +213,8 @@ private:
         m_exporter.getFromContext().getSourceManager().getFileID(loc);
     if (file != m_file)
       return false;
-    // We are assuming the Decl was parsed in this very expression, so it should
-    // not have external storage.
+    // We are assuming the Decl was parsed in this very expression, so it
+    // should not have external storage.
     lldbassert(!llvm::cast<DeclContext>(decl)->hasExternalLexicalStorage());
     return true;
   }
@@ -591,8 +591,8 @@ bool ClangExpressionDeclMap::GetFunctionInfo(const NamedDecl *decl,
   if (!entity)
     return false;
 
-  // We know m_parser_vars is valid since we searched for the variable by
-  // its NamedDecl
+  // We know m_parser_vars is valid since we searched for the variable by its
+  // NamedDecl
 
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
@@ -867,8 +867,8 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
   if (IgnoreName(name, false))
     return;
 
-  // Only look for functions by name out in our symbols if the function
-  // doesn't start with our phony prefix of '$'
+  // Only look for functions by name out in our symbols if the function doesn't
+  // start with our phony prefix of '$'
   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
   SymbolContext sym_ctx;
@@ -977,13 +977,11 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
           m_struct_vars->m_object_pointer_type = self_user_type;
         }
       } else {
-        // This branch will get hit if we are executing code in the context of a
-        // function that
-        // claims to have an object pointer (through DW_AT_object_pointer?) but
-        // is not formally a
-        // method of the class.  In that case, just look up the "this" variable
-        // in the current
-        // scope and use its type.
+        // This branch will get hit if we are executing code in the context of
+        // a function that claims to have an object pointer (through
+        // DW_AT_object_pointer?) but is not formally a method of the class.
+        // In that case, just look up the "this" variable in the current scope
+        // and use its type.
         // FIXME: This code is formally correct, but clang doesn't currently
         // emit DW_AT_object_pointer
         // for C++ so it hasn't actually been tested.
@@ -1093,13 +1091,11 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
 
         return;
       } else {
-        // This branch will get hit if we are executing code in the context of a
-        // function that
-        // claims to have an object pointer (through DW_AT_object_pointer?) but
-        // is not formally a
-        // method of the class.  In that case, just look up the "self" variable
-        // in the current
-        // scope and use its type.
+        // This branch will get hit if we are executing code in the context of
+        // a function that claims to have an object pointer (through
+        // DW_AT_object_pointer?) but is not formally a method of the class.
+        // In that case, just look up the "self" variable in the current scope
+        // and use its type.
 
         VariableList *vars = frame->GetVariableList(false);
 
@@ -1217,9 +1213,8 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
           vars->GetVariableAtIndex(i)->GetDecl();
 
         // Search for declarations matching the name. Do not include imported
-        // decls
-        // in the search if we are looking for decls in the artificial namespace
-        // $__lldb_local_vars.
+        // decls in the search if we are looking for decls in the artificial
+        // namespace $__lldb_local_vars.
         std::vector<CompilerDecl> found_decls =
             compiler_decl_context.FindDeclByName(name,
                                                  namespace_decl.IsValid());
@@ -1285,15 +1280,15 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
                                         append, sc_list);
     }
 
-    // If we found more than one function, see if we can use the
-    // frame's decl context to remove functions that are shadowed
-    // by other functions which match in type but are nearer in scope.
+    // If we found more than one function, see if we can use the frame's decl
+    // context to remove functions that are shadowed by other functions which
+    // match in type but are nearer in scope.
     //
     // AddOneFunction will not add a function whose type has already been
-    // added, so if there's another function in the list with a matching
-    // type, check to see if their decl context is a parent of the current
-    // frame's or was imported via a and using statement, and pick the
-    // best match according to lookup rules.
+    // added, so if there's another function in the list with a matching type,
+    // check to see if their decl context is a parent of the current frame's or
+    // was imported via a and using statement, and pick the best match
+    // according to lookup rules.
     if (sc_list.GetSize() > 1) {
       // Collect some info about our frame's context.
       StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
@@ -1321,11 +1316,10 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
           SymbolContext m_sym_ctx;
         };
 
-        // First, symplify things by looping through the symbol contexts
-        // to remove unwanted functions and separate out the functions we
-        // want to compare and prune into a separate list.
-        // Cache the info needed about the function declarations in a
-        // vector for efficiency.
+        // First, symplify things by looping through the symbol contexts to
+        // remove unwanted functions and separate out the functions we want to
+        // compare and prune into a separate list. Cache the info needed about
+        // the function declarations in a vector for efficiency.
         SymbolContextList sc_sym_list;
         uint32_t num_indices = sc_list.GetSize();
         std::vector<FuncDeclInfo> fdi_cache;
@@ -1335,16 +1329,16 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
           SymbolContext sym_ctx;
           sc_list.GetContextAtIndex(index, sym_ctx);
 
-          // We don't know enough about symbols to compare them,
-          // but we should keep them in the list.
+          // We don't know enough about symbols to compare them, but we should
+          // keep them in the list.
           Function *function = sym_ctx.function;
           if (!function) {
             sc_sym_list.Append(sym_ctx);
             continue;
           }
           // Filter out functions without declaration contexts, as well as
-          // class/instance methods, since they'll be skipped in the
-          // code that follows anyway.
+          // class/instance methods, since they'll be skipped in the code that
+          // follows anyway.
           CompilerDeclContext func_decl_context = function->GetDeclContext();
           if (!func_decl_context ||
               func_decl_context.IsClassMethod(nullptr, nullptr, nullptr))
@@ -1363,11 +1357,10 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
           fdi.m_copied_type = copied_func_type;
           fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL;
           if (fdi.m_copied_type && func_decl_context) {
-            // Call CountDeclLevels to get the number of parent scopes we
-            // have to look through before we find the function declaration.
-            // When comparing functions of the same type, the one with a
-            // lower count will be closer to us in the lookup scope and
-            // shadows the other.
+            // Call CountDeclLevels to get the number of parent scopes we have
+            // to look through before we find the function declaration. When
+            // comparing functions of the same type, the one with a lower count
+            // will be closer to us in the lookup scope and shadows the other.
             clang::DeclContext *func_decl_ctx =
                 (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
             fdi.m_decl_lvl = ast->CountDeclLevels(
@@ -1536,9 +1529,8 @@ void ClangExpressionDeclMap::FindExternalVisibleDecls(
     }
 
     if (target && !context.m_found.variable && !namespace_decl) {
-      // We couldn't find a non-symbol variable for this.  Now we'll hunt for
-      // a generic
-      // data symbol, and -- if it is found -- treat it as a variable.
+      // We couldn't find a non-symbol variable for this.  Now we'll hunt for a
+      // generic data symbol, and -- if it is found -- treat it as a variable.
       Status error;
 
       const Symbol *data_symbol =
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
index d9e53074b3fb..6151e97bcd80 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
@@ -182,8 +182,7 @@ public:
         m_manager->AddDiagnostic(new_diagnostic);
 
         // Don't store away warning fixits, since the compiler doesn't have
-        // enough
-        // context in an expression for the warning to be useful.
+        // enough context in an expression for the warning to be useful.
         // FIXME: Should we try to filter out FixIts that apply to our generated
         // code, and not the user's expression?
         if (severity == eDiagnosticSeverityError) {
@@ -226,10 +225,9 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
       m_code_generator(), m_pp_callbacks(nullptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  // We can't compile expressions without a target.  So if the exe_scope is null
-  // or doesn't have a target,
-  // then we just need to get out of here.  I'll lldb_assert and not make any of
-  // the compiler objects since
+  // We can't compile expressions without a target.  So if the exe_scope is
+  // null or doesn't have a target, then we just need to get out of here.  I'll
+  // lldb_assert and not make any of the compiler objects since
   // I can't return errors directly from the constructor.  Further calls will
   // check if the compiler was made and
   // bag out if it wasn't.
@@ -262,14 +260,14 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
 
   const auto target_machine = target_arch.GetMachine();
 
-  // If the expression is being evaluated in the context of an existing
-  // stack frame, we introspect to see if the language runtime is available.
+  // If the expression is being evaluated in the context of an existing stack
+  // frame, we introspect to see if the language runtime is available.
 
   lldb::StackFrameSP frame_sp = exe_scope->CalculateStackFrame();
   lldb::ProcessSP process_sp = exe_scope->CalculateProcess();
 
-  // Make sure the user hasn't provided a preferred execution language
-  // with `expression --language X -- ...`
+  // Make sure the user hasn't provided a preferred execution language with
+  // `expression --language X -- ...`
   if (frame_sp && frame_lang == lldb::eLanguageTypeUnknown)
     frame_lang = frame_sp->GetLanguage();
 
@@ -281,8 +279,7 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   }
 
   // 2. Configure the compiler with a set of default options that are
-  // appropriate
-  // for most situations.
+  // appropriate for most situations.
   if (target_arch.IsValid()) {
     std::string triple = target_arch.GetTriple().str();
     m_compiler->getTargetOpts().Triple = triple;
@@ -292,19 +289,17 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   } else {
     // If we get here we don't have a valid target and just have to guess.
     // Sometimes this will be ok to just use the host target triple (when we
-    // evaluate say "2+3", but other
-    // expressions like breakpoint conditions and other things that _are_ target
-    // specific really shouldn't just be
-    // using the host triple. In such a case the language runtime should expose
-    // an overridden options set (3),
-    // below.
+    // evaluate say "2+3", but other expressions like breakpoint conditions and
+    // other things that _are_ target specific really shouldn't just be using
+    // the host triple. In such a case the language runtime should expose an
+    // overridden options set (3), below.
     m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
     if (log)
       log->Printf("Using default target triple of %s",
                   m_compiler->getTargetOpts().Triple.c_str());
   }
-  // Now add some special fixes for known architectures:
-  // Any arm32 iOS environment, but not on arm64
+  // Now add some special fixes for known architectures: Any arm32 iOS
+  // environment, but not on arm64
   if (m_compiler->getTargetOpts().Triple.find("arm64") == std::string::npos &&
       m_compiler->getTargetOpts().Triple.find("arm") != std::string::npos &&
       m_compiler->getTargetOpts().Triple.find("ios") != std::string::npos) {
@@ -317,8 +312,8 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
     m_compiler->getTargetOpts().Features.push_back("+sse2");
   }
 
-  // Set the target CPU to generate code for.
-  // This will be empty for any CPU that doesn't really need to make a special
+  // Set the target CPU to generate code for. This will be empty for any CPU
+  // that doesn't really need to make a special
   // CPU string.
   m_compiler->getTargetOpts().CPU = target_arch.GetClangTargetCPU();
 
@@ -328,11 +323,9 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
     m_compiler->getTargetOpts().ABI = abi;
 
   // 3. Now allow the runtime to provide custom configuration options for the
-  // target.
-  // In this case, a specialized language runtime is available and we can query
-  // it for extra options.
-  // For 99% of use cases, this will not be needed and should be provided when
-  // basic platform detection is not enough.
+  // target. In this case, a specialized language runtime is available and we
+  // can query it for extra options. For 99% of use cases, this will not be
+  // needed and should be provided when basic platform detection is not enough.
   if (lang_rt)
     overridden_target_opts =
         lang_rt->GetOverrideExprOptions(m_compiler->getTargetOpts());
@@ -378,9 +371,9 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   case lldb::eLanguageTypeC11:
     // FIXME: the following language option is a temporary workaround,
     // to "ask for C, get C++."
-    // For now, the expression parser must use C++ anytime the
-    // language is a C family language, because the expression parser
-    // uses features of C++ to capture values.
+    // For now, the expression parser must use C++ anytime the language is a C
+    // family language, because the expression parser uses features of C++ to
+    // capture values.
     m_compiler->getLangOpts().CPlusPlus = true;
     break;
   case lldb::eLanguageTypeObjC:
@@ -392,10 +385,10 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
 
     // Clang now sets as default C++14 as the default standard (with
     // GNU extensions), so we do the same here to avoid mismatches that
-    // cause compiler error when evaluating expressions (e.g. nullptr
-    // not found as it's a C++11 feature). Currently lldb evaluates
-    // C++14 as C++11 (see two lines below) so we decide to be consistent
-    // with that, but this could be re-evaluated in the future.
+    // cause compiler error when evaluating expressions (e.g. nullptr not found
+    // as it's a C++11 feature). Currently lldb evaluates C++14 as C++11 (see
+    // two lines below) so we decide to be consistent with that, but this could
+    // be re-evaluated in the future.
     m_compiler->getLangOpts().CPlusPlus11 = true;
     break;
   case lldb::eLanguageTypeC_plus_plus:
@@ -407,8 +400,8 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   case lldb::eLanguageTypeC_plus_plus_03:
     m_compiler->getLangOpts().CPlusPlus = true;
     // FIXME: the following language option is a temporary workaround,
-    // to "ask for C++, get ObjC++".  Apple hopes to remove this requirement
-    // on non-Apple platforms, but for now it is needed.
+    // to "ask for C++, get ObjC++".  Apple hopes to remove this requirement on
+    // non-Apple platforms, but for now it is needed.
     m_compiler->getLangOpts().ObjC1 = true;
     break;
   case lldb::eLanguageTypeObjC_plus_plus:
@@ -434,10 +427,9 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
       ArchSpec(m_compiler->getTargetOpts().Triple.c_str())
           .CharIsSignedByDefault();
 
-  // Spell checking is a nice feature, but it ends up completing a
-  // lot of types that we didn't strictly speaking need to complete.
-  // As a result, we spend a long time parsing and importing debug
-  // information.
+  // Spell checking is a nice feature, but it ends up completing a lot of types
+  // that we didn't strictly speaking need to complete. As a result, we spend a
+  // long time parsing and importing debug information.
   m_compiler->getLangOpts().SpellChecking = false;
 
   if (process_sp && m_compiler->getLangOpts().ObjC1) {
@@ -513,8 +505,8 @@ ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
     m_compiler->getPreprocessor().addPPCallbacks(std::move(pp_callbacks));
   }
 
-  // 8. Most of this we get from the CompilerInstance, but we
-  // also want to give the context an ExternalASTSource.
+  // 8. Most of this we get from the CompilerInstance, but we also want to give
+  // the context an ExternalASTSource.
   m_selector_table.reset(new SelectorTable());
   m_builtin_context.reset(new Builtin::Context());
 
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp
index a26ceda82d5f..e3e0ed49181e 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp
@@ -101,14 +101,12 @@ ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp,
   m_wrapper_function_text.append(" (*fn_ptr) (");
 
   // Get the number of arguments.  If we have a function type and it is
-  // prototyped,
-  // trust that, otherwise use the values we were given.
+  // prototyped, trust that, otherwise use the values we were given.
 
   // FIXME: This will need to be extended to handle Variadic functions.  We'll
   // need
   // to pull the defined arguments out of the function, then add the types from
-  // the
-  // arguments list for the variable arguments.
+  // the arguments list for the variable arguments.
 
   uint32_t num_args = UINT32_MAX;
   bool trust_function = false;
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
index eaa0315d1463..020f8821f0b1 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
@@ -40,9 +40,9 @@
 using namespace lldb_private;
 
 namespace {
-// Any Clang compiler requires a consumer for diagnostics.  This one stores them
-// as strings
-// so we can provide them to the user in case a module failed to load.
+// Any Clang compiler requires a consumer for diagnostics.  This one stores
+// them as strings so we can provide them to the user in case a module failed
+// to load.
 class StoringDiagnosticConsumer : public clang::DiagnosticConsumer {
 public:
   StoringDiagnosticConsumer();
@@ -62,8 +62,7 @@ private:
 };
 
 // The private implementation of our ClangModulesDeclVendor.  Contains all the
-// Clang state required
-// to load modules.
+// Clang state required to load modules.
 class ClangModulesDeclVendorImpl : public ClangModulesDeclVendor {
 public:
   ClangModulesDeclVendorImpl(
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
index 18fe8b49227b..d6526c08f1b0 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp
@@ -195,12 +195,10 @@ void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
   } else if (clang::FunctionDecl *function_decl =
                  ClangASTContext::DeclContextGetAsFunctionDecl(decl_context)) {
     // We might also have a function that said in the debug information that it
-    // captured an
-    // object pointer.  The best way to deal with getting to the ivars at
-    // present is by pretending
-    // that this is a method of a class in whatever runtime the debug info says
-    // the object pointer
-    // belongs to.  Do that here.
+    // captured an object pointer.  The best way to deal with getting to the
+    // ivars at present is by pretending that this is a method of a class in
+    // whatever runtime the debug info says the object pointer belongs to.  Do
+    // that here.
 
     ClangASTMetadata *metadata =
         ClangASTContext::DeclContextGetMetaData(decl_context, function_decl);
@@ -290,10 +288,10 @@ void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
   }
 }
 
-// This is a really nasty hack, meant to fix Objective-C expressions of the form
-// (int)[myArray count].  Right now, because the type information for count is
-// not available, [myArray count] returns id, which can't be directly cast to
-// int without causing a clang error.
+// This is a really nasty hack, meant to fix Objective-C expressions of the
+// form (int)[myArray count].  Right now, because the type information for
+// count is not available, [myArray count] returns id, which can't be directly
+// cast to int without causing a clang error.
 static void ApplyObjcCastHack(std::string &expr) {
 #define OBJC_CAST_HACK_FROM "(int)["
 #define OBJC_CAST_HACK_TO "(int)(long long)["
@@ -463,17 +461,15 @@ bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
     exe_scope = exe_ctx.GetTargetPtr();
 
   // We use a shared pointer here so we can use the original parser - if it
-  // succeeds
-  // or the rewrite parser we might make if it fails.  But the parser_sp will
-  // never be empty.
+  // succeeds or the rewrite parser we might make if it fails.  But the
+  // parser_sp will never be empty.
 
   ClangExpressionParser parser(exe_scope, *this, generate_debug_info);
 
   unsigned num_errors = parser.Parse(diagnostic_manager);
 
   // Check here for FixItHints.  If there are any try to apply the fixits and
-  // set the fixed text in m_fixed_text
-  // before returning an error.
+  // set the fixed text in m_fixed_text before returning an error.
   if (num_errors) {
     if (diagnostic_manager.HasFixIts()) {
       if (parser.RewriteExpression(diagnostic_manager)) {
@@ -495,8 +491,8 @@ bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////
-  // Prepare the output of the parser for execution, evaluating it statically if
-  // possible
+  // Prepare the output of the parser for execution, evaluating it statically
+  // if possible
   //
 
   {
@@ -539,9 +535,9 @@ bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
       register_execution_unit = true;
     }
 
-    // If there is more than one external function in the execution
-    // unit, it needs to keep living even if it's not top level, because
-    // the result could refer to that function.
+    // If there is more than one external function in the execution unit, it
+    // needs to keep living even if it's not top level, because the result
+    // could refer to that function.
 
     if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
       register_execution_unit = true;
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
index 13f5657eedd8..e51c9ee07b9f 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
@@ -263,8 +263,7 @@ bool IRForTarget::CreateResultVariable(llvm::Function &llvm_function) {
   }
 
   // Get the next available result name from m_decl_map and create the
-  // persistent
-  // variable for it
+  // persistent variable for it
 
   // If the result is an Lvalue, it is emitted as a pointer; see
   // ASTResultSynthesizer::SynthesizeBodyResult.
@@ -345,9 +344,9 @@ bool IRForTarget::CreateResultVariable(llvm::Function &llvm_function) {
       GlobalValue::ExternalLinkage, NULL, /* no initializer */
       m_result_name.GetCString());
 
-  // It's too late in compilation to create a new VarDecl for this, but we don't
-  // need to.  We point the metadata at the old VarDecl.  This creates an odd
-  // anomaly: a variable with a Value whose name is something like $0 and a
+  // It's too late in compilation to create a new VarDecl for this, but we
+  // don't need to.  We point the metadata at the old VarDecl.  This creates an
+  // odd anomaly: a variable with a Value whose name is something like $0 and a
   // Decl whose name is $__lldb_expr_result.  This condition is handled in
   // ClangExpressionDeclMap::DoMaterialize, and the name of the variable is
   // fixed up.
@@ -464,9 +463,7 @@ bool IRForTarget::RewriteObjCConstString(llvm::GlobalVariable *ns_str,
     // CFAllocatorRef -> i8*
     // UInt8 * -> i8*
     // CFIndex -> long (i32 or i64, as appropriate; we ask the module for its
-    // pointer size for now)
-    // CFStringEncoding -> i32
-    // Boolean -> i8
+    // pointer size for now) CFStringEncoding -> i32 Boolean -> i8
 
     Type *arg_type_array[5];
 
@@ -801,9 +798,8 @@ bool IRForTarget::RewriteObjCSelector(Instruction *selector_load) {
   // Unpack the message name from the selector.  In LLVM IR, an objc_msgSend
   // gets represented as
   //
-  // %tmp     = load i8** @"OBJC_SELECTOR_REFERENCES_" ; <i8*>
-  // %call    = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...)
-  // ; <i8*>
+  // %tmp     = load i8** @"OBJC_SELECTOR_REFERENCES_" ; <i8*> %call    = call
+  // i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...) ; <i8*>
   //
   // where %obj is the object pointer and %tmp is the selector.
   //
@@ -870,7 +866,8 @@ bool IRForTarget::RewriteObjCSelector(Instruction *selector_load) {
       log->Printf("Found sel_registerName at 0x%" PRIx64,
                   sel_registerName_addr);
 
-    // Build the function type: struct objc_selector *sel_registerName(uint8_t*)
+    // Build the function type: struct objc_selector
+    // *sel_registerName(uint8_t*)
 
     // The below code would be "more correct," but in actuality what's required
     // is uint8_t*
@@ -980,11 +977,10 @@ bool IRForTarget::RewriteObjCClassReference(Instruction *class_load) {
   //            %struct._objc_class** @OBJC_CLASS_REFERENCES_, align 4
   //
   // @"OBJC_CLASS_REFERENCES_ is a bitcast of a character array called
-  // @OBJC_CLASS_NAME_.
-  // @OBJC_CLASS_NAME contains the string.
+  // @OBJC_CLASS_NAME_. @OBJC_CLASS_NAME contains the string.
 
-  // Find the pointer's initializer (a ConstantExpr with opcode BitCast)
-  // and get the string from its target
+  // Find the pointer's initializer (a ConstantExpr with opcode BitCast) and
+  // get the string from its target
 
   GlobalVariable *_objc_class_references_ =
       dyn_cast<GlobalVariable>(load->getPointerOperand());
@@ -1159,8 +1155,8 @@ bool IRForTarget::RewritePersistentAlloc(llvm::Instruction *persistent_alloc) {
       GlobalValue::ExternalLinkage, NULL,   /* no initializer */
       alloc->getName().str());
 
-  // What we're going to do here is make believe this was a regular old external
-  // variable.  That means we need to make the metadata valid.
+  // What we're going to do here is make believe this was a regular old
+  // external variable.  That means we need to make the metadata valid.
 
   NamedMDNode *named_metadata =
       m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
@@ -1175,8 +1171,7 @@ bool IRForTarget::RewritePersistentAlloc(llvm::Instruction *persistent_alloc) {
   named_metadata->addOperand(persistent_global_md);
 
   // Now, since the variable is a pointer variable, we will drop in a load of
-  // that
-  // pointer variable.
+  // that pointer variable.
 
   LoadInst *persistent_load = new LoadInst(persistent_global, "", alloc);
 
@@ -1366,16 +1361,13 @@ bool IRForTarget::MaybeHandleVariable(Value *llvm_value_ptr) {
 
     if (name[0] == '$') {
       // The $__lldb_expr_result name indicates the return value has allocated
-      // as
-      // a static variable.  Per the comment at
-      // ASTResultSynthesizer::SynthesizeBodyResult,
-      // accesses to this static variable need to be redirected to the result of
-      // dereferencing
-      // a pointer that is passed in as one of the arguments.
+      // as a static variable.  Per the comment at
+      // ASTResultSynthesizer::SynthesizeBodyResult, accesses to this static
+      // variable need to be redirected to the result of dereferencing a
+      // pointer that is passed in as one of the arguments.
       //
       // Consequently, when reporting the size of the type, we report a pointer
-      // type pointing
-      // to the type of $__lldb_expr_result, not the type itself.
+      // type pointing to the type of $__lldb_expr_result, not the type itself.
       //
       // We also do this for any user-declared persistent variables.
       compiler_type = compiler_type.GetPointerType();
@@ -1965,12 +1957,11 @@ bool IRForTarget::ReplaceVariables(Function &llvm_function) {
       FunctionValueCache body_result_maker(
           [this, name, offset_type, offset, argument,
            value](llvm::Function *function) -> llvm::Value * {
-            // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult, in
-            // cases where the result
-            // variable is an rvalue, we have to synthesize a dereference of the
-            // appropriate structure
-            // entry in order to produce the static variable that the AST thinks
-            // it is accessing.
+            // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
+            // in cases where the result variable is an rvalue, we have to
+            // synthesize a dereference of the appropriate structure entry in
+            // order to produce the static variable that the AST thinks it is
+            // accessing.
 
             llvm::Instruction *entry_instruction = llvm::cast<Instruction>(
                 m_entry_instruction_finder.GetValue(function));
@@ -2194,7 +2185,8 @@ bool IRForTarget::runOnModule(Module &llvm_module) {
         if (log)
           log->Printf("RewriteObjCSelectors() failed");
 
-        // RewriteObjCSelectors() reports its own errors, so we don't do so here
+        // RewriteObjCSelectors() reports its own errors, so we don't do so
+        // here
 
         return false;
       }
diff --git a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
index f4b8cfbe03d4..48c006a2cf7f 100644
--- a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
@@ -400,8 +400,7 @@ ValueObjectSP GoUserExpression::GoInterpreter::VisitIdent(const GoASTIdent *e) {
         val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
       else {
         // When a variable is on the heap instead of the stack, go records a
-        // variable
-        // '&x' instead of 'x'.
+        // variable '&x' instead of 'x'.
         var_sp = var_list_sp->FindVariable(ConstString("&" + varname));
         if (var_sp) {
           val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);