[clang-tidy] DO NOT SUBMIT.. example diff of applying bugprone-argument-comments with AddCommentsToXXXLiterals options

[MyDeveloperDay]

Summary

This review is an example to be used in the review process to show how new options impact a typical clang library (in this case clang-tidy/modernize)

this is the result of applying D57674: [clang-tidy] Add options to bugprone-argument-comment to add missing argument comments to literals

[MyDeveloperDay]

Update demo diff, with support for Argument Comments for also StringLiteral,CharacterLiterals,UserDefinedLiterals and NullPtrs

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.cpp

void AvoidBindCheck::check(const MatchFinder::MatchResult &Result) {
   llvm::raw_string_ostream Stream(Buffer);
 
   bool HasCapturedArgument = llvm::any_of(
       Args, [](const BindArgument &B) { return B.Kind == BK_Other; });
   const auto *Ref = Result.Nodes.getNodeAs<DeclRefExpr>("ref");
   Stream << "[" << (HasCapturedArgument ? "=" : "") << "]";
   addPlaceholderArgs(Args, Stream);
   Stream << " { return ";
-  Ref->printPretty(Stream, nullptr, Result.Context->getPrintingPolicy());
+  Ref->printPretty(Stream, /*Helper=*/nullptr, Result.Context->getPrintingPolicy());
   Stream << "(";
   addFunctionCallArgs(Args, Stream);
   Stream << "); };";
 
   Diag << FixItHint::CreateReplacement(MatchedDecl->getSourceRange(),
                                        Stream.str());
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

 static bool alreadyConcatenated(std::size_t NumCandidates,
                                 const SourceRange &ReplacementRange,
                                 const SourceManager &Sources,
                                 const LangOptions &LangOpts) {
   CharSourceRange TextRange =
       Lexer::getAsCharRange(ReplacementRange, Sources, LangOpts);
   StringRef CurrentNamespacesText =
       Lexer::getSourceText(TextRange, Sources, LangOpts);
-  return CurrentNamespacesText.count(':') == (NumCandidates - 1) * 2;
+  return CurrentNamespacesText.count(/*C=*/':') == (NumCandidates - 1) * 2;
 }
 
 ConcatNestedNamespacesCheck::NamespaceString
 ConcatNestedNamespacesCheck::concatNamespaces() {
   NamespaceString Result("namespace ");
   Result.append(Namespaces.front()->getName());
 
   std::for_each(std::next(Namespaces.begin()), Namespaces.end(),

clang-tools-extra/clang-tidy/modernize/DeprecatedHeadersCheck.cpp

void IncludeModernizePPCallbacks::InclusionDirective(
   //
   // Reasonable options for the check:
   //
   // 1. Insert std prefix for every such symbol occurrence.
   // 2. Insert `using namespace std;` to the beginning of TU.
   // 3. Do nothing and let the user deal with the migration himself.
   if (CStyledHeaderToCxx.count(FileName) != 0) {
     std::string Replacement =
-        (llvm::Twine("<") + CStyledHeaderToCxx[FileName] + ">").str();
+        (llvm::Twine(/*Str=*/"<") + CStyledHeaderToCxx[FileName] + ">").str();
     Check.diag(FilenameRange.getBegin(), "inclusion of deprecated C++ header "
                                          "'%0'; consider using '%1' instead")
         << FileName << CStyledHeaderToCxx[FileName]
         << FixItHint::CreateReplacement(FilenameRange.getAsRange(),
                                         Replacement);
   } else if (DeleteHeaders.count(FileName) != 0) {
     Check.diag(FilenameRange.getBegin(),
                "including '%0' has no effect in C++; consider removing it")
         << FileName << FixItHint::CreateRemoval(
                            SourceRange(HashLoc, FilenameRange.getEnd()));
   }
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 static const llvm::SmallVector<StringRef, 5> DeprecatedTypes = {
-    {"::std::ios_base::io_state"},
-    {"::std::ios_base::open_mode"},
-    {"::std::ios_base::seek_dir"},
-    {"::std::ios_base::streamoff"},
-    {"::std::ios_base::streampos"}};
+    {/*Str=*/"::std::ios_base::io_state"},
+    {/*Str=*/"::std::ios_base::open_mode"},
+    {/*Str=*/"::std::ios_base::seek_dir"},
+    {/*Str=*/"::std::ios_base::streamoff"},
+    {/*Str=*/"::std::ios_base::streampos"}};
 
 static const llvm::StringMap<StringRef> ReplacementTypes = {
     {"io_state", "iostate"},
     {"open_mode", "openmode"},
     {"seek_dir", "seekdir"}};
 
 void DeprecatedIosBaseAliasesCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

 static StringRef getStringFromRange(SourceManager &SourceMgr,
                                     const LangOptions &LangOpts,
                                     SourceRange Range) {
   if (SourceMgr.getFileID(Range.getBegin()) !=
       SourceMgr.getFileID(Range.getEnd())) {
     return StringRef(); // Empty string.
   }
 
-  return Lexer::getSourceText(CharSourceRange(Range, true), SourceMgr,
+  return Lexer::getSourceText(CharSourceRange(Range, /*ITR=*/true), SourceMgr,
                               LangOpts);
 }
 
 /// \brief If the given expression is actually a DeclRefExpr or a MemberExpr,
 /// find and return the underlying ValueDecl; otherwise, return NULL.
 static const ValueDecl *getReferencedVariable(const Expr *E) {
   if (const DeclRefExpr *DRE = getDeclRef(E))
     return dyn_cast<VarDecl>(DRE->getDecl());

 /// next instruction.
 ///
 /// We need to delete a potential newline after the deleted alias, as
 /// clang-format will leave empty lines untouched. For all other formatting we
 /// rely on clang-format to fix it.
 void LoopConvertCheck::getAliasRange(SourceManager &SM, SourceRange &Range) {
   bool Invalid = false;
   const char *TextAfter =
-      SM.getCharacterData(Range.getEnd().getLocWithOffset(1), &Invalid);
+      SM.getCharacterData(Range.getEnd().getLocWithOffset(/*Offset=*/1), &Invalid);
   if (Invalid)
     return;
-  unsigned Offset = std::strspn(TextAfter, " \t\r\n");
+  unsigned Offset = std::strspn(TextAfter, /*_Control=*/" \t\r\n");
   Range =
       SourceRange(Range.getBegin(), Range.getEnd().getLocWithOffset(Offset));
 }
 
 /// \brief Computes the changes needed to convert a given for loop, and
 /// applies them.
 void LoopConvertCheck::doConversion(
     ASTContext *Context, const VarDecl *IndexVar,

clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp

 }
 
 /// \brief Returns true when two Exprs are equivalent.
 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second) {
   if (!First || !Second)
     return false;
 
   llvm::FoldingSetNodeID FirstID, SecondID;
-  First->Profile(FirstID, *Context, true);
-  Second->Profile(SecondID, *Context, true);
+  First->Profile(FirstID, *Context, /*Canonical=*/true);
+  Second->Profile(SecondID, *Context, /*Canonical=*/true);
   return FirstID == SecondID;
 }
 
 /// \brief Returns the DeclRefExpr represented by E, or NULL if there isn't one.
 const DeclRefExpr *getDeclRef(const Expr *E) {
   return dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
 }
 
static const Expr *getDereferenceOperand(const Expr *E) {
   return nullptr;
 }
 
 /// \brief Returns true when the Container contains an Expr equivalent to E.
 template <typename ContainerT>
 static bool containsExpr(ASTContext *Context, const ContainerT *Container,
                          const Expr *E) {
   llvm::FoldingSetNodeID ID;
-  E->Profile(ID, *Context, true);
+  E->Profile(ID, *Context, /*Canonical=*/true);
   for (const auto &I : *Container) {
     if (ID == I.second)
       return true;
   }
   return false;
 }
 
 /// \brief Returns true when the index expression is a declaration reference to
void ForLoopIndexUseVisitor::addComponents(const ComponentVector &Components) {
   // FIXME: add sort(on ID)+unique to avoid extra work.
   for (const auto &I : Components)
     addComponent(I);
 }
 
 void ForLoopIndexUseVisitor::addComponent(const Expr *E) {
   llvm::FoldingSetNodeID ID;
   const Expr *Node = E->IgnoreParenImpCasts();
-  Node->Profile(ID, *Context, true);
+  Node->Profile(ID, *Context, /*Canonical=*/true);
   DependentExprs.push_back(std::make_pair(Node, ID));
 }
 
 void ForLoopIndexUseVisitor::addUsage(const Usage &U) {
   SourceLocation Begin = U.Range.getBegin();
   if (Begin.isMacroID())
     Begin = Context->getSourceManager().getSpellingLoc(Begin);
 
bool ForLoopIndexUseVisitor::TraverseLambdaCapture(LambdaExpr *LE,
                                                    const LambdaCapture *C,
                                                    Expr *Init) {
   if (C->capturesVariable()) {
     const VarDecl *VDecl = C->getCapturedVar();
     if (areSameVariable(IndexVar, cast<ValueDecl>(VDecl))) {
       // FIXME: if the index is captured, it will count as an usage and the
       // alias (if any) won't work, because it is only used in case of having
       // exactly one usage.
-      addUsage(Usage(nullptr,
+      addUsage(Usage(/*E=*/nullptr,
                      C->getCaptureKind() == LCK_ByCopy ? Usage::UK_CaptureByCopy
                                                        : Usage::UK_CaptureByRef,
                      C->getLocation()));
     }
   }
   return VisitorBase::TraverseLambdaCapture(LE, C, Init);
 }
 

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name,
                                      StringRef MakeSmartPtrFunctionName)
     : ClangTidyCheck(Name, Context),
       IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
       MakeSmartPtrFunctionHeader(
           Options.get("MakeSmartPtrFunctionHeader", StdMemoryHeader)),
       MakeSmartPtrFunctionName(
           Options.get("MakeSmartPtrFunction", MakeSmartPtrFunctionName)),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", /*Default=*/true)) {}
 
 void MakeSmartPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IncludeStyle", IncludeStyle);
   Options.store(Opts, "MakeSmartPtrFunctionHeader", MakeSmartPtrFunctionHeader);
   Options.store(Opts, "MakeSmartPtrFunction", MakeSmartPtrFunctionName);
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
Diag << FixItHint::CreateReplacement(
       MakeSmartPtrFunctionName);
 
   // If the smart_ptr is built with brace enclosed direct initialization, use
   // parenthesis instead.
   if (Construct->isListInitialization()) {
     SourceRange BraceRange = Construct->getParenOrBraceRange();
     Diag << FixItHint::CreateReplacement(
         CharSourceRange::getCharRange(
-            BraceRange.getBegin(), BraceRange.getBegin().getLocWithOffset(1)),
+            BraceRange.getBegin(), BraceRange.getBegin().getLocWithOffset(/*Offset=*/1)),
         "(");
     Diag << FixItHint::CreateReplacement(
         CharSourceRange::getCharRange(BraceRange.getEnd(),
-                                      BraceRange.getEnd().getLocWithOffset(1)),
+                                      BraceRange.getEnd().getLocWithOffset(/*Offset=*/1)),
         ")");
   }
 
   insertHeader(Diag, SM.getFileID(ConstructCallStart));
 }
 
 void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
                                    const CXXMemberCallExpr *Reset,
void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
   }
 
   if (!replaceNew(Diag, New, SM, Ctx)) {
     return;
   }
 
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(OperatorLoc, ExprEnd),
-      (llvm::Twine(" = ") + MakeSmartPtrFunctionName + "<" +
+      (llvm::Twine(/*Str=*/" = ") + MakeSmartPtrFunctionName + "<" +
        GetNewExprName(New, SM, getLangOpts()) + ">")
           .str());
 
   if (Expr->isArrow())
     Diag << FixItHint::CreateInsertion(ExprStart, "*");
 
   insertHeader(Diag, SM.getFileID(OperatorLoc));
 }
if (const auto *NewConstruct = New->getConstructExpr()) {
         //   struct S { S(int x); S(); };
         //   smart_ptr<S>(new S{5});
         //   smart_ptr<S>(new S{}); // use default constructor
         // The arguments in the initialization list are going to be forwarded to
         // the constructor, so this has to be replaced with:
         //   std::make_smart_ptr<S>(5);
         //   std::make_smart_ptr<S>();
         InitRange = SourceRange(
-            NewConstruct->getParenOrBraceRange().getBegin().getLocWithOffset(1),
+            NewConstruct->getParenOrBraceRange().getBegin().getLocWithOffset(/*Offset=*/1),
             NewConstruct->getParenOrBraceRange().getEnd().getLocWithOffset(-1));
       }
     } else {
       // Aggregate initialization.
       //   smart_ptr<Pair>(new Pair{first, second});
       // Has to be replaced with:
       //   smart_ptr<Pair>(Pair{first, second});
       //
if (const auto *NewConstruct = New->getConstructExpr()) {
       }
       InitRange = SourceRange(
           New->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
           New->getInitializer()->getSourceRange().getEnd());
     }
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getCharRange(NewStart, InitRange.getBegin()));
     Diag << FixItHint::CreateRemoval(
-        SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd));
+        SourceRange(InitRange.getEnd().getLocWithOffset(/*Offset=*/1), NewEnd));
     break;
   }
   }
   return true;
 }
 
 void MakeSmartPtrCheck::insertHeader(DiagnosticBuilder &Diag, FileID FD) {
   if (MakeSmartPtrFunctionHeader.empty()) {

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

for (const FunctionDecl *Redecl : Ctor->redecls())
     Results.push_back(Redecl->getParamDecl(ParamIdx));
   return Results;
 }
 
 PassByValueCheck::PassByValueCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
-      ValuesOnly(Options.get("ValuesOnly", 0) != 0) {}
+      ValuesOnly(Options.get("ValuesOnly", /*Default=*/0) != 0) {}
 
 void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IncludeStyle",
                 utils::IncludeSorter::toString(IncludeStyle));
   Options.store(Opts, "ValuesOnly", ValuesOnly);
 }
 
 void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
std::string ValueStr = Lexer::getSourceText(CharSourceRange::getTokenRange(
                                .str();
     ValueStr += ' ';
     Diag << FixItHint::CreateReplacement(TypeRange, ValueStr);
   }
 
   // Use std::move in the initialization list.
   Diag << FixItHint::CreateInsertion(Initializer->getRParenLoc(), ")")
        << FixItHint::CreateInsertion(
-              Initializer->getLParenLoc().getLocWithOffset(1), "std::move(");
+              Initializer->getLParenLoc().getLocWithOffset(/*Offset=*/1), "std::move(");
 
   if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
           Result.SourceManager->getFileID(Initializer->getSourceLocation()),
           "utility",
           /*IsAngled=*/true)) {
     Diag << *IncludeFixit;
   }
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/RawStringLiteralCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 namespace {
 
 bool containsEscapes(StringRef HayStack, StringRef Escapes) {
-  size_t BackSlash = HayStack.find('\\');
+  size_t BackSlash = HayStack.find(/*C=*/'\\');
   if (BackSlash == StringRef::npos)
     return false;
 
   while (BackSlash != StringRef::npos) {
     if (Escapes.find(HayStack[BackSlash + 1]) == StringRef::npos)
       return false;
-    BackSlash = HayStack.find('\\', BackSlash + 2);
+    BackSlash = HayStack.find(/*C=*/'\\', BackSlash + 2);
   }
 
   return true;
 }
 
 bool isRawStringLiteral(StringRef Text) {
   // Already a raw string literal if R comes before ".
-  const size_t QuotePos = Text.find('"');
+  const size_t QuotePos = Text.find(/*C=*/'"');
   assert(QuotePos != StringRef::npos);
   return (QuotePos > 0) && (Text[QuotePos - 1] == 'R');
 }
 
 bool containsEscapedCharacters(const MatchFinder::MatchResult &Result,
                                const StringLiteral *Literal,
                                const CharsBitSet &DisallowedChars) {
   // FIXME: Handle L"", u8"", u"" and U"" literals.
bool containsEscapedCharacters(const MatchFinder::MatchResult &Result,
   if (isRawStringLiteral(Text))
     return false;
 
   return containsEscapes(Text, R"('\"?x01)");
 }
 
 bool containsDelimiter(StringRef Bytes, const std::string &Delimiter) {
   return Bytes.find(Delimiter.empty()
-                        ? std::string(R"lit()")lit")
+                        ? std::string(/*_Ptr=*/R"lit()")lit")
                         : (")" + Delimiter + R"(")")) != StringRef::npos;
 }
 
 std::string asRawStringLiteral(const StringLiteral *Literal,
                                const std::string &DelimiterStem) {
   const StringRef Bytes = Literal->getBytes();
   std::string Delimiter;
   for (int I = 0; containsDelimiter(Bytes, Delimiter); ++I) {
     Delimiter = (I == 0) ? DelimiterStem : DelimiterStem + std::to_string(I);
   }
 
   if (Delimiter.empty())
     return (R"(R"()" + Bytes + R"lit()")lit").str();
 
   return (R"(R")" + Delimiter + "(" + Bytes + ")" + Delimiter + R"(")").str();
 }
 
 } // namespace
 
 RawStringLiteralCheck::RawStringLiteralCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       DelimiterStem(Options.get("DelimiterStem", "lit")),
-      ReplaceShorterLiterals(Options.get("ReplaceShorterLiterals", false)) {
+      ReplaceShorterLiterals(Options.get("ReplaceShorterLiterals", /*Default=*/false)) {
   // Non-printing characters are disallowed:
   // \007 = \a bell
   // \010 = \b backspace
   // \011 = \t horizontal tab
   // \012 = \n new line
   // \013 = \v vertical tab
   // \014 = \f form feed
   // \015 = \r carriage return
   // \177 = delete
-  for (const unsigned char C : StringRef("\000\001\002\003\004\005\006\a"
+  for (const unsigned char C : StringRef(/*data=*/"\000\001\002\003\004\005\006\a"
                                          "\b\t\n\v\f\r\016\017"
                                          "\020\021\022\023\024\025\026\027"
                                          "\030\031\032\033\034\035\036\037"
                                          "\177",
                                          33))
     DisallowedChars.set(C);
 
   // Non-ASCII are disallowed too.

clang-tools-extra/clang-tidy/modernize/RedundantVoidArgCheck.cpp

if (State == SawVoid && ProtoToken.is(tok::TokenKind::r_paren)) {
     removeVoidToken(VoidToken, Diagnostic);
   }
 }
 
 void RedundantVoidArgCheck::removeVoidToken(Token VoidToken,
                                             StringRef Diagnostic) {
   SourceLocation VoidLoc(VoidToken.getLocation());
   auto VoidRange =
-      CharSourceRange::getTokenRange(VoidLoc, VoidLoc.getLocWithOffset(3));
+      CharSourceRange::getTokenRange(VoidLoc, VoidLoc.getLocWithOffset(/*Offset=*/3));
   diag(VoidLoc, Diagnostic) << FixItHint::CreateRemoval(VoidRange);
 }
 
 void RedundantVoidArgCheck::processTypedefNameDecl(
     const MatchFinder::MatchResult &Result,
     const TypedefNameDecl *TypedefName) {
   if (protoTypeHasNoParms(TypedefName->getUnderlyingType())) {
     removeVoidArgumentTokens(Result, TypedefName->getSourceRange(),

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

if (const auto *TL = Result.Nodes.getNodeAs<TypeLoc>(AutoPtrTokenId)) {
     if (auto Loc = TL->getAs<TemplateSpecializationTypeLoc>())
       AutoPtrLoc = Loc.getTemplateNameLoc();
   } else if (const auto *D =
                  Result.Nodes.getNodeAs<UsingDecl>(AutoPtrTokenId)) {
     // using std::auto_ptr;
     //            ^
     AutoPtrLoc = D->getNameInfo().getBeginLoc();
   } else {
-    llvm_unreachable("Bad Callback. No node provided.");
+    llvm_unreachable(/*msg=*/"Bad Callback. No node provided.");
   }
 
   if (AutoPtrLoc.isMacroID())
     AutoPtrLoc = SM.getSpellingLoc(AutoPtrLoc);
 
   // Ensure that only the 'auto_ptr' token is replaced and not the template
   // aliases.
-  if (StringRef(SM.getCharacterData(AutoPtrLoc), strlen("auto_ptr")) !=
+  if (StringRef(SM.getCharacterData(AutoPtrLoc), strlen(/*_Str=*/"auto_ptr")) !=
       "auto_ptr")
     return;
 
   SourceLocation EndLoc =
-      AutoPtrLoc.getLocWithOffset(strlen("auto_ptr") - 1);
+      AutoPtrLoc.getLocWithOffset(strlen(/*_Str=*/"auto_ptr") - 1);
   diag(AutoPtrLoc, "auto_ptr is deprecated, use unique_ptr instead")
       << FixItHint::CreateReplacement(SourceRange(AutoPtrLoc, EndLoc),
                                       "unique_ptr");
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp

return declStmt(
       anyOf(makeIteratorDeclMatcher(), makeDeclWithNewMatcher(),
             makeDeclWithCastMatcher(), makeDeclWithTemplateCastMatcher()));
 }
 
 } // namespace
 
 UseAutoCheck::UseAutoCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      MinTypeNameLength(Options.get("MinTypeNameLength", 5)),
-      RemoveStars(Options.get("RemoveStars", 0)) {}
+      MinTypeNameLength(Options.get("MinTypeNameLength", /*Default=*/5)),
+      RemoveStars(Options.get("RemoveStars", /*Default=*/0)) {}
 
 void UseAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinTypeNameLength", MinTypeNameLength);
   Options.store(Opts, "RemoveStars", RemoveStars ? 1 : 0);
 }
 
 void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
for (const auto *Dec : D->decls()) {
     }
 
     if (const auto *NestedConstruct = dyn_cast<CXXConstructExpr>(E)) {
       // If we ran into an implicit conversion contructor, can't convert.
       //
       // FIXME: The following only checks if the constructor can be used
       // implicitly, not if it actually was. Cases where the converting
       // constructor was used explicitly won't get converted.
-      if (NestedConstruct->getConstructor()->isConvertingConstructor(false))
+      if (NestedConstruct->getConstructor()->isConvertingConstructor(/*AllowExplicit=*/false))
         return;
     }
     if (!Context->hasSameType(V->getType(), E->getType()))
       return;
   }
 
   // Get the type location using the first declaration.
   const auto *V = cast<VarDecl>(*D->decl_begin());
replaceExpr(
         [](const Expr *Expr) {
           return cast<CallExpr>(Expr->IgnoreImplicit())
               ->getDirectCallee()
               ->getReturnType();
         },
         "use auto when initializing with a template cast to avoid duplicating "
         "the type name");
   } else {
-    llvm_unreachable("Bad Callback. No node provided.");
+    llvm_unreachable(/*msg=*/"Bad Callback. No node provided.");
   }
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/UseBoolLiteralsCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseBoolLiteralsCheck::UseBoolLiteralsCheck(StringRef Name,
                                            ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", /*Default=*/true)) {}
 
 void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
       implicitCastExpr(
           has(ignoringParenImpCasts(integerLiteral().bind("literal"))),

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

case BuiltinType::SatUShortFract:
       return "0.0uhr";
     case BuiltinType::UFract:
     case BuiltinType::SatUFract:
       return "0.0ur";
     case BuiltinType::ULongFract:
     case BuiltinType::SatULongFract:
       return "0.0ulr";
     default:
-      llvm_unreachable("Unhandled fixed point BuiltinType");
+      llvm_unreachable(/*msg=*/"Unhandled fixed point BuiltinType");
     }
   }
-  llvm_unreachable("Invalid scalar type kind");
+  llvm_unreachable(/*msg=*/"Invalid scalar type kind");
 }
 
 static bool isZero(const Expr *E) {
   switch (E->getStmtClass()) {
   case Stmt::CXXNullPtrLiteralExprClass:
   case Stmt::ImplicitValueInitExprClass:
     return true;
   case Stmt::InitListExprClass:
static bool sameValue(const Expr *E1, const Expr *E2) {
   default:
     return false;
   }
 }
 
 UseDefaultMemberInitCheck::UseDefaultMemberInitCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      UseAssignment(Options.get("UseAssignment", 0) != 0),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true) != 0) {}
+      UseAssignment(Options.get("UseAssignment", /*Default=*/0) != 0),
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", /*Default=*/true) != 0) {}
 
 void UseDefaultMemberInitCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "UseAssignment", UseAssignment);
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UseDefaultMemberInitCheck::registerMatchers(MatchFinder *Finder) {

 void UseDefaultMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Default =
           Result.Nodes.getNodeAs<CXXCtorInitializer>("default"))
     checkDefaultInit(Result, Default);
   else if (const auto *Existing =
                Result.Nodes.getNodeAs<CXXCtorInitializer>("existing"))
     checkExistingInit(Result, Existing);
   else
-    llvm_unreachable("Bad Callback. No node provided.");
+    llvm_unreachable(/*msg=*/"Bad Callback. No node provided.");
 }
 
 void UseDefaultMemberInitCheck::checkDefaultInit(
     const MatchFinder::MatchResult &Result, const CXXCtorInitializer *Init) {
   const FieldDecl *Field = Init->getAnyMember();
 
   SourceLocation StartLoc = Field->getBeginLoc();
   if (StartLoc.isMacroID() && IgnoreMacros)

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

 const auto DefaultSmartPointers =
     "::std::shared_ptr; ::std::unique_ptr; ::std::auto_ptr; ::std::weak_ptr";
 const auto DefaultTupleTypes = "::std::pair; ::std::tuple";
 const auto DefaultTupleMakeFunctions = "::std::make_pair; ::std::make_tuple";
 } // namespace
 
 UseEmplaceCheck::UseEmplaceCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IgnoreImplicitConstructors(Options.get("IgnoreImplicitConstructors", 0)),
+      IgnoreImplicitConstructors(Options.get("IgnoreImplicitConstructors", /*Default=*/0)),
       ContainersWithPushBack(utils::options::parseStringList(Options.get(
           "ContainersWithPushBack", DefaultContainersWithPushBack))),
       SmartPointers(utils::options::parseStringList(
           Options.get("SmartPointers", DefaultSmartPointers))),
       TupleTypes(utils::options::parseStringList(
           Options.get("TupleTypes", DefaultTupleTypes))),
       TupleMakeFunctions(utils::options::parseStringList(
           Options.get("TupleMakeFunctions", DefaultTupleMakeFunctions))) {}

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
   // Ensure that we don't do anything else.
   return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
 }
 
 /// \brief Returns false if the body has any non-whitespace character.
 static bool bodyEmpty(const ASTContext *Context, const CompoundStmt *Body) {
   bool Invalid = false;
   StringRef Text = Lexer::getSourceText(
-      CharSourceRange::getCharRange(Body->getLBracLoc().getLocWithOffset(1),
+      CharSourceRange::getCharRange(Body->getLBracLoc().getLocWithOffset(/*Offset=*/1),
                                     Body->getRBracLoc()),
       Context->getSourceManager(), Context->getLangOpts(), &Invalid);
-  return !Invalid && std::strspn(Text.data(), " \t\r\n") == Text.size();
+  return !Invalid && std::strspn(Text.data(), /*_Control=*/" \t\r\n") == Text.size();
 }
 
 UseEqualsDefaultCheck::UseEqualsDefaultCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true) != 0) {}
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", /*Default=*/true) != 0) {}
 
 void UseEqualsDefaultCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UseEqualsDefaultCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseNoexceptCheck::UseNoexceptCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       NoexceptMacro(Options.get("ReplacementString", "")),
-      UseNoexceptFalse(Options.get("UseNoexceptFalse", true)) {}
+      UseNoexceptFalse(Options.get("UseNoexceptFalse", /*Default=*/true)) {}
 
 void UseNoexceptCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ReplacementString", NoexceptMacro);
   Options.store(Opts, "UseNoexceptFalse", UseNoexceptFalse);
 }
 
 void UseNoexceptCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp

bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc,
   return SM.isWrittenInSameFile(StartLoc, EndLoc);
 }
 
 /// \brief Replaces the provided range with the text "nullptr", but only if
 /// the start and end location are both in main file.
 /// Returns true if and only if a replacement was made.
 void replaceWithNullptr(ClangTidyCheck &Check, SourceManager &SM,
                         SourceLocation StartLoc, SourceLocation EndLoc) {
-  CharSourceRange Range(SourceRange(StartLoc, EndLoc), true);
+  CharSourceRange Range(SourceRange(StartLoc, EndLoc), /*ITR=*/true);
   // Add a space if nullptr follows an alphanumeric character. This happens
   // whenever there is an c-style explicit cast to nullptr not surrounded by
   // parentheses and right beside a return statement.
   SourceLocation PreviousLocation = StartLoc.getLocWithOffset(-1);
   bool NeedsSpace = isAlphanumeric(*SM.getCharacterData(PreviousLocation));
   Check.diag(Range.getBegin(), "use nullptr") << FixItHint::CreateReplacement(
       Range, NeedsSpace ? " nullptr" : "nullptr");
 }
bool allArgUsesValid(const CastExpr *CE) {
     // from the given arg location.
     // Visitor needs: arg loc.
     MacroArgUsageVisitor ArgUsageVisitor(SM.getFileLoc(CastLoc), SM);
     if (const auto *D = ContainingAncestor.get<Decl>())
       ArgUsageVisitor.TraverseDecl(const_cast<Decl *>(D));
     else if (const auto *S = ContainingAncestor.get<Stmt>())
       ArgUsageVisitor.TraverseStmt(const_cast<Stmt *>(S));
     else
-      llvm_unreachable("Unhandled ContainingAncestor node type");
+      llvm_unreachable(/*msg=*/"Unhandled ContainingAncestor node type");
 
     return !ArgUsageVisitor.foundInvalid();
   }
 
   /// \brief Given the SourceLocation for a macro arg expansion, finds the
   /// non-macro SourceLocation of the macro the arg was passed to and the
   /// non-macro SourceLocation of the argument in the arg list to that macro.
   /// These results are returned via \c MacroLoc and \c ArgLoc respectively.
while (true) {
       FileID MacroFID = SM.getFileID(MacroLoc);
       if (SM.isInFileID(ArgLoc, MacroFID)) {
         // Don't transform this case. If the characters that caused the
         // null-conversion come from within a macro, they can't be changed.
         return false;
       }
     }
 
-    llvm_unreachable("getMacroAndArgLocations");
+    llvm_unreachable(/*msg=*/"getMacroAndArgLocations");
   }
 
   /// \brief Tests if TestMacroLoc is found while recursively unravelling
   /// expansions starting at TestLoc. TestMacroLoc.isFileID() must be true.
   /// Implementation is very similar to getMacroAndArgLocations() except in this
   /// case, it's not assumed that TestLoc is expanded from a macro argument.
   /// While unravelling expansions macro arguments are handled as with
   /// getMacroAndArgLocations() but in this function macro body expansions are
while (true) {
       Loc = Expansion.getSpellingLoc().getLocWithOffset(LocInfo.second);
       if (Loc.isFileID()) {
         // If we made it this far without finding a match, there is no match to
         // be made.
         return false;
       }
     }
 
-    llvm_unreachable("expandsFrom");
+    llvm_unreachable(/*msg=*/"expandsFrom");
   }
 
   /// \brief Given a starting point \c Start in the AST, find an ancestor that
   /// doesn't expand from the macro called at file location \c MacroLoc.
   ///
   /// \pre MacroLoc.isFileID()
   /// \returns true if such an ancestor was found, false otherwise.
   bool findContainingAncestor(ast_type_traits::DynTypedNode Start,
while (true) {
         if (!expandsFrom(Loc, MacroLoc)) {
           Result = Parent;
           return true;
         }
       }
       Start = Parent;
     }
 
-    llvm_unreachable("findContainingAncestor");
+    llvm_unreachable(/*msg=*/"findContainingAncestor");
   }
 
 private:
   SourceManager &SM;
   ASTContext &Context;
   ArrayRef<StringRef> NullMacros;
   ClangTidyCheck &Check;
   Expr *FirstSubExpr;

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseTransparentFunctorsCheck::UseTransparentFunctorsCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", 0)) {}
+    : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", /*Default=*/0)) {}
 
 void UseTransparentFunctorsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "SafeMode", SafeMode ? 1 : 0);
 }
 
 void UseTransparentFunctorsCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus14)

clang-tools-extra/clang-tidy/modernize/UseUsingCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 UseUsingCheck::UseUsingCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", /*Default=*/true)) {}
 
 void UseUsingCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
   Finder->addMatcher(typedefDecl(unless(isInstantiated())).bind("typedef"),
                      this);
 }