[clang-tidy][NFC] Tweak some generation of diag messages

[njames93]

Summary

Fix up cases where diag is called by piecing together a string in favour of placeholders.
Fix up cases where select could be used instead of duplicating the message for sake of 1 word difference.

[njames93]

Fix up portability-simd-intrinsics diagnostic.

[aaron.ballman]

LGTM! Thanks, these are really nice cleanups!

clang-tools-extra/clang-tidy/abseil/DurationFactoryFloatCheck.cpp

void DurationFactoryFloatCheck::check(const MatchFinder::MatchResult &Result) {
   if (Arg->getBeginLoc().isMacroID())
     return;
 
   llvm::Optional<std::string> SimpleArg = stripFloatCast(Result, *Arg);
   if (!SimpleArg)
     SimpleArg = stripFloatLiteralFraction(Result, *Arg);
 
   if (SimpleArg) {
-    diag(MatchedCall->getBeginLoc(),
-         (llvm::Twine("use the integer version of absl::") +
-          MatchedCall->getDirectCallee()->getName())
-             .str())
+    diag(MatchedCall->getBeginLoc(), "use the integer version of absl::%0")
+        << MatchedCall->getDirectCallee()->getName()
         << FixItHint::CreateReplacement(Arg->getSourceRange(), *SimpleArg);
   }
 }
 
 } // namespace abseil
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

void StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {
   const StringRef NeedleExprCode = Lexer::getSourceText(
       CharSourceRange::getTokenRange(Needle->getSourceRange()), Source,
       Context.getLangOpts());
   const StringRef HaystackExprCode = Lexer::getSourceText(
       CharSourceRange::getTokenRange(Haystack->getSourceRange()), Source,
       Context.getLangOpts());
 
   // Create the StartsWith string, negating if comparison was "!=".
-  bool Neg = ComparisonExpr->getOpcodeStr() == "!=";
-  StringRef StartswithStr;
-  if (Neg) {
-    StartswithStr = "!absl::StartsWith";
-  } else {
-    StartswithStr = "absl::StartsWith";
-  }
+  bool Neg = ComparisonExpr->getOpcode() == BO_NE;
 
   // Create the warning message and a FixIt hint replacing the original expr.
-  auto Diagnostic =
-      diag(ComparisonExpr->getBeginLoc(),
-           (StringRef("use ") + StartswithStr + " instead of find() " +
-            ComparisonExpr->getOpcodeStr() + " 0")
-               .str());
+  auto Diagnostic = diag(ComparisonExpr->getBeginLoc(),
+                         "use %select{absl::StartsWith|!absl::StartsWith}0 "
+                         "instead of find() %select{==|!=}0 0")
+                    << Neg;
 
   Diagnostic << FixItHint::CreateReplacement(
       ComparisonExpr->getSourceRange(),
-      (StartswithStr + "(" + HaystackExprCode + ", " + NeedleExprCode + ")")
+      ((Neg ? "!absl::StartsWith(" : "absl::StartsWith(") + HaystackExprCode +
+       ", " + NeedleExprCode + ")")
           .str());
 
   // Create a preprocessor #include FixIt hint (CreateIncludeInsertion checks
   // whether this already exists).
   Diagnostic << IncludeInserter.createIncludeInsertion(
       Source.getFileID(ComparisonExpr->getBeginLoc()),
       AbseilStringsMatchHeader);
 }

clang-tools-extra/clang-tidy/bugprone/ExceptionEscapeCheck.cpp

void ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
 
   if (!MatchedDecl)
     return;
 
   if (Tracer.analyze(MatchedDecl).getBehaviour() ==
       utils::ExceptionAnalyzer::State::Throwing)
     // FIXME: We should provide more information about the exact location where
     // the exception is thrown, maybe the full path the exception escapes
-    diag(MatchedDecl->getLocation(),
-         "an exception may be thrown in function %0 "
-
-         "which should not throw exceptions")
+    diag(MatchedDecl->getLocation(), "an exception may be thrown in function "
+                                     "%0 which should not throw exceptions")
         << MatchedDecl;
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/bugprone/ParentVirtualCallCheck.cpp

for (const CXXRecordDecl *Parent : Parents) {
     if (!ParentsStr.empty())
       ParentsStr.append(" or ");
     ParentsStr.append("'").append(getNameAsString(Parent)).append("'");
   }
 
   assert(Member->getQualifierLoc().getSourceRange().getBegin().isValid());
   auto Diag = diag(Member->getQualifierLoc().getSourceRange().getBegin(),
                    "qualified name '%0' refers to a member overridden "
-                   "in subclass%1; did you mean %2?")
+                   "in %plural{1:subclass|:subclasses}1; did you mean %2?")
               << getExprAsString(*Member, *Result.Context)
-              << (Parents.size() > 1 ? "es" : "") << ParentsStr;
+              << static_cast<unsigned>(Parents.size()) << ParentsStr;
 
   // Propose a fix if there's only one parent class...
   if (Parents.size() == 1 &&
       // ...unless parent class is templated
       !isa<ClassTemplateSpecializationDecl>(Parents.front()))
     Diag << FixItHint::CreateReplacement(
         Member->getQualifierLoc().getSourceRange(),
         getNameAsString(Parents.front()) + "::");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

void ProTypeMemberInitCheck::checkMissingMemberInitializer(
   SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit;
   forEachField(ClassDecl, FieldsToInit,
                [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });
   if (AllFieldsToInit.empty())
     return;
 
   DiagnosticBuilder Diag =
       diag(Ctor ? Ctor->getBeginLoc() : ClassDecl.getLocation(),
-           IsUnion
-               ? "union constructor should initialize one of these fields: %0"
-               : "constructor does not initialize these fields: %0")
-      << toCommaSeparatedString(OrderedFields, AllFieldsToInit);
+           "%select{|union }0constructor %select{does not|should}0 initialize "
+           "%select{|one of }0these fields: %1")
+      << IsUnion << toCommaSeparatedString(OrderedFields, AllFieldsToInit);
 
   // Do not propose fixes for constructors in macros since we cannot place them
   // correctly.
   if (Ctor && Ctor->getBeginLoc().isMacroID())
     return;
 
   // Collect all fields but only suggest a fix for the first member of unions,
   // as initializing more than one union member is an error.

clang-tools-extra/clang-tidy/llvm/PreferRegisterOverUnsignedCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void PreferRegisterOverUnsignedCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *VarType = Result.Nodes.getNodeAs<QualType>("varType");
   const auto *UserVarDecl = Result.Nodes.getNodeAs<VarDecl>("var");
 
-  StringRef Replacement = "llvm::Register";
+  bool NeedsQualification = true;
   const DeclContext *Context = UserVarDecl->getDeclContext();
   while (Context) {
     if (const auto *Namespace = dyn_cast<NamespaceDecl>(Context))
       if (isa<TranslationUnitDecl>(Namespace->getDeclContext()) &&
           Namespace->getName() == "llvm")
-        Replacement = "Register";
+        NeedsQualification = false;
     for (const auto *UsingDirective : Context->using_directives()) {
       const NamespaceDecl *Namespace = UsingDirective->getNominatedNamespace();
       if (isa<TranslationUnitDecl>(Namespace->getDeclContext()) &&
           Namespace->getName() == "llvm")
-        Replacement = "Register";
+        NeedsQualification = false;
     }
     Context = Context->getParent();
   }
   diag(UserVarDecl->getLocation(),
-       "variable %0 declared as %1; use '%2' instead")
-      << UserVarDecl << *VarType << Replacement
+       "variable %0 declared as %1; use '%select{|llvm::}2Register' instead")
+      << UserVarDecl << *VarType << NeedsQualification
       << FixItHint::CreateReplacement(
              UserVarDecl->getTypeSourceInfo()->getTypeLoc().getSourceRange(),
-             Replacement);
+             NeedsQualification ? "llvm::Register" : "Register");
 }
 
 } // namespace llvm_check
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
                      this);
 }
 
 void UnconventionalAssignOperatorCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) {
     diag(RetStmt->getBeginLoc(), "operator=() should always return '*this'");
   } else {
-    static const char *const Messages[][2] = {
-        {"ReturnType", "operator=() should return '%0&'"},
-        {"ArgumentType",
-         getLangOpts().CPlusPlus11
-             ? "operator=() should take '%0 const&', '%0&&' or '%0'"
-             : "operator=() should take '%0 const&' or '%0'"},
-        {"cv", "operator=() should not be marked '%1'"}};
-
     const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
-    for (const auto &Message : Messages) {
-      if (Result.Nodes.getNodeAs<Decl>(Message[0]))
-        diag(Method->getBeginLoc(), Message[1])
-            << Method->getParent()->getName()
-            << (Method->isConst() ? "const" : "virtual");
-    }
+    if (Result.Nodes.getNodeAs<CXXMethodDecl>("ReturnType"))
+      diag(Method->getBeginLoc(), "operator=() should return '%0&'")
+          << Method->getParent()->getName();
+    if (Result.Nodes.getNodeAs<CXXMethodDecl>("ArgumentType"))
+      diag(Method->getBeginLoc(),
+           "operator=() should take '%0 const&'%select{|, '%0&&'}1 or '%0'")
+          << Method->getParent()->getName() << getLangOpts().CPlusPlus11;
+    if (Result.Nodes.getNodeAs<CXXMethodDecl>("cv"))
+      diag(Method->getBeginLoc(),
+           "operator=() should not be marked '%select{const|virtual}0'")
+          << !Method->isConst();
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

void UniqueptrResetReleaseCheck::check(const MatchFinder::MatchResult &Result) {
   std::string RightText = std::string(clang::Lexer::getSourceText(
       CharSourceRange::getTokenRange(Right->getSourceRange()),
       *Result.SourceManager, getLangOpts()));
 
   if (ResetMember->isArrow())
     LeftText = "*" + LeftText;
   if (ReleaseMember->isArrow())
     RightText = "*" + RightText;
-  std::string DiagText;
+  bool IsMove = false;
   // Even if x was rvalue, *x is not rvalue anymore.
   if (!Right->isRValue() || ReleaseMember->isArrow()) {
     RightText = "std::move(" + RightText + ")";
-    DiagText = "prefer ptr1 = std::move(ptr2) over ptr1.reset(ptr2.release())";
-  } else {
-    DiagText =
-        "prefer ptr = ReturnUnique() over ptr.reset(ReturnUnique().release())";
+    IsMove = true;
   }
+
   std::string NewText = LeftText + " = " + RightText;
 
-  diag(ResetMember->getExprLoc(), DiagText) << FixItHint::CreateReplacement(
-      CharSourceRange::getTokenRange(ResetCall->getSourceRange()), NewText);
+  diag(ResetMember->getExprLoc(),
+       "prefer ptr = %select{std::move(ptr2)|ReturnUnique()}0 over "
+       "ptr.reset(%select{ptr2|ReturnUnique()}0.release())")
+      << !IsMove
+      << FixItHint::CreateReplacement(
+             CharSourceRange::getTokenRange(ResetCall->getSourceRange()),
+             NewText);
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

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

Finder->addMatcher(
                            hasAncestor(functionDecl(isExternC())))))
           .bind("typeloc"),
       this);
 }
 
 void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
 
-  static constexpr llvm::StringLiteral UseArray = llvm::StringLiteral(
-      "do not declare C-style arrays, use std::array<> instead");
-  static constexpr llvm::StringLiteral UseVector = llvm::StringLiteral(
-      "do not declare C VLA arrays, use std::vector<> instead");
-
   diag(ArrayType->getBeginLoc(),
-       ArrayType->getTypePtr()->isVariableArrayType() ? UseVector : UseArray);
+       "do not declare %select{C-style|C VLA}0 arrays, use "
+       "%select{std::array<>|std::vector<>}0 instead")
+      << ArrayType->getTypePtr()->isVariableArrayType();
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

Finder->addMatcher(
                     // passed by value, and in this case it cannot be
                     // defaulted.
                     hasParameter(0, hasType(lValueReferenceType())))
           .bind(SpecialFunction),
       this);
 }
 
 void UseEqualsDefaultCheck::check(const MatchFinder::MatchResult &Result) {
-  std::string SpecialFunctionName;
-
   // Both CXXConstructorDecl and CXXDestructorDecl inherit from CXXMethodDecl.
   const auto *SpecialFunctionDecl =
       Result.Nodes.getNodeAs<CXXMethodDecl>(SpecialFunction);
 
   if (IgnoreMacros && SpecialFunctionDecl->getLocation().isMacroID())
     return;
 
   // Discard explicitly deleted/defaulted special member functions and those
void UseEqualsDefaultCheck::check(const MatchFinder::MatchResult &Result) {
   if (!SpecialFunctionDecl->isCopyAssignmentOperator() && !Body->body_empty())
     return;
 
   // If there are comments inside the body, don't do the change.
   bool ApplyFix = SpecialFunctionDecl->isCopyAssignmentOperator() ||
                   bodyEmpty(Result.Context, Body);
 
   std::vector<FixItHint> RemoveInitializers;
-
+  unsigned MemberType;
   if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(SpecialFunctionDecl)) {
     if (Ctor->getNumParams() == 0) {
-      SpecialFunctionName = "default constructor";
+      MemberType = 0;
     } else {
       if (!isCopyConstructorAndCanBeDefaulted(Result.Context, Ctor))
         return;
-      SpecialFunctionName = "copy constructor";
+      MemberType = 1;
       // If there are constructor initializers, they must be removed.
       for (const auto *Init : Ctor->inits()) {
         RemoveInitializers.emplace_back(
             FixItHint::CreateRemoval(Init->getSourceRange()));
       }
     }
   } else if (isa<CXXDestructorDecl>(SpecialFunctionDecl)) {
-    SpecialFunctionName = "destructor";
+    MemberType = 2;
   } else {
     if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, SpecialFunctionDecl))
       return;
-    SpecialFunctionName = "copy-assignment operator";
+    MemberType = 3;
   }
 
   // The location of the body is more useful inside a macro as spelling and
   // expansion locations are reported.
   SourceLocation Location = SpecialFunctionDecl->getLocation();
   if (Location.isMacroID())
     Location = Body->getBeginLoc();
 
-  auto Diag = diag(Location, "use '= default' to define a trivial " +
-                                 SpecialFunctionName);
+  auto Diag = diag(
+      Location,
+      "use '= default' to define a trivial %select{default constructor|copy "
+      "constructor|destructor|copy-assignment operator}0");
+  Diag << MemberType;
 
   if (ApplyFix) {
     // Skipping comments, check for a semicolon after Body->getSourceRange()
     Optional<Token> Token = utils::lexer::findNextTokenSkippingComments(
         Body->getSourceRange().getEnd().getLocWithOffset(1),
         Result.Context->getSourceManager(), Result.Context->getLangOpts());
     StringRef Replacement =
         Token && Token->is(tok::semi) ? "= default" : "= default;";
     Diag << FixItHint::CreateReplacement(Body->getSourceRange(), Replacement)
          << RemoveInitializers;
   }
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

void UseNodiscardCheck::check(const MatchFinder::MatchResult &Result) {
   SourceLocation Loc = MatchedDecl->getLocation();
   if (Loc.isInvalid() || Loc.isMacroID())
     return;
 
   SourceLocation RetLoc = MatchedDecl->getInnerLocStart();
 
   ASTContext &Context = *Result.Context;
 
-  auto Diag = diag(RetLoc, "function %0 should be marked " + NoDiscardMacro)
-              << MatchedDecl;
+  auto Diag = diag(RetLoc, "function %0 should be marked %1")
+              << MatchedDecl << NoDiscardMacro;
 
   // Check for the existence of the keyword being used as the ``[[nodiscard]]``.
   if (!doesNoDiscardMacroExist(Context, NoDiscardMacro))
     return;
 
   // Possible false positives include:
   // 1. A const member function which returns a variable which is ignored
   // but performs some external I/O operation and the return value could be

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

void UseTransparentFunctorsCheck::registerMatchers(MatchFinder *Finder) {
   // to rule out the problematic char* vs string case.
   Finder->addMatcher(cxxConstructExpr(hasDeclaration(cxxMethodDecl(
                                           ofClass(TransparentFunctors))),
                                       unless(isInTemplateInstantiation()))
                          .bind("FuncInst"),
                      this);
 }
 
-static const StringRef Message = "prefer transparent functors '%0'";
+static const StringRef Message = "prefer transparent functors '%0<>'";
 
 template <typename T> static T getInnerTypeLocAs(TypeLoc Loc) {
   T Result;
   while (Result.isNull() && !Loc.isNull()) {
     Result = Loc.getAs<T>();
     Loc = Loc.getNextTypeLoc();
   }
   return Result;
 }
 
 void UseTransparentFunctorsCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *FuncClass =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("FunctorClass");
   if (const auto *FuncInst =
           Result.Nodes.getNodeAs<CXXConstructExpr>("FuncInst")) {
-    diag(FuncInst->getBeginLoc(), Message)
-        << (FuncClass->getName() + "<>").str();
+    diag(FuncInst->getBeginLoc(), Message) << FuncClass->getName();
     return;
   }
 
   const auto *Functor = Result.Nodes.getNodeAs<TemplateArgument>("Functor");
   const auto FunctorParentLoc =
       Result.Nodes.getNodeAs<TypeLoc>("FunctorParentLoc")
           ->getAs<TemplateSpecializationTypeLoc>();
 
void UseTransparentFunctorsCheck::check(
   auto FunctorTypeLoc = getInnerTypeLocAs<TemplateSpecializationTypeLoc>(
       FunctorLoc.getTypeSourceInfo()->getTypeLoc());
   if (FunctorTypeLoc.isNull())
     return;
 
   SourceLocation ReportLoc = FunctorLoc.getLocation();
   if (ReportLoc.isInvalid())
     return;
-  diag(ReportLoc, Message) << (FuncClass->getName() + "<>").str()
+  diag(ReportLoc, Message) << FuncClass->getName()
                            << FixItHint::CreateRemoval(
                                   FunctorTypeLoc.getArgLoc(0).getSourceRange());
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp

if (Ctor->isMoveConstructor() && Ctor->getAccess() <= AS_protected &&
       break;
     }
   }
 
   if (Candidate) {
     // There's a move constructor candidate that the caller probably intended
     // to call instead.
     diag(Initializer->getSourceLocation(),
-         "move constructor initializes %0 by calling a copy constructor")
-        << (Initializer->isBaseInitializer() ? "base class" : "class member");
+         "move constructor initializes %select{class member|base class}0 by "
+         "calling a copy constructor")
+        << Initializer->isBaseInitializer();
     diag(CopyCtor->getLocation(), "copy constructor being called",
          DiagnosticIDs::Note);
     diag(Candidate->getLocation(), "candidate move constructor here",
          DiagnosticIDs::Note);
   }
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

Finder->addMatcher(
                     unless(isImplicit()), unless(isDeleted()))
           .bind("decl"),
       this);
 }
 
 void NoexceptMoveConstructorCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *Decl = Result.Nodes.getNodeAs<CXXMethodDecl>("decl")) {
-    StringRef MethodType = "assignment operator";
+    bool IsConstructor = false;
     if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Decl)) {
       if (!Ctor->isMoveConstructor())
         return;
-      MethodType = "constructor";
+      IsConstructor = true;
     } else if (!Decl->isMoveAssignmentOperator()) {
       return;
     }
 
     const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
 
     if (isUnresolvedExceptionSpec(ProtoType->getExceptionSpecType()))
       return;
 
     if (!isNoexceptExceptionSpec(ProtoType->getExceptionSpecType())) {
-      auto Diag =
-          diag(Decl->getLocation(), "move %0s should be marked noexcept")
-          << MethodType;
+      auto Diag = diag(Decl->getLocation(),
+                       "move %select{assignment operator|constructor}0s should "
+                       "be marked noexcept")
+                  << IsConstructor;
       // Add FixIt hints.
       SourceManager &SM = *Result.SourceManager;
       assert(Decl->getNumParams() > 0);
       SourceLocation NoexceptLoc = Decl->getParamDecl(Decl->getNumParams() - 1)
                                        ->getSourceRange()
                                        .getEnd();
       if (NoexceptLoc.isValid())
         NoexceptLoc = Lexer::findLocationAfterToken(
             NoexceptLoc, tok::r_paren, SM, Result.Context->getLangOpts(), true);
       if (NoexceptLoc.isValid())
         Diag << FixItHint::CreateInsertion(NoexceptLoc, " noexcept ");
       return;
     }
 
     // Don't complain about nothrow(false), but complain on nothrow(expr)
     // where expr evaluates to false.
     if (ProtoType->canThrow() == CT_Can) {
       Expr *E = ProtoType->getNoexceptExpr();
       E = E->IgnoreImplicit();
       if (!isa<CXXBoolLiteralExpr>(E)) {
         diag(E->getExprLoc(),
-             "noexcept specifier on the move %0 evaluates to 'false'")
-            << MethodType;
+             "noexcept specifier on the move %select{assignment "
+             "operator|constructor}0 evaluates to 'false'")
+            << IsConstructor;
       }
     }
   }
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/UnnecessaryCopyInitialization.cpp

void UnnecessaryCopyInitialization::handleCopyFromMethodReturn(
   if (!IsConstQualified && !isOnlyUsedAsConst(Var, BlockStmt, Context))
     return;
   if (ObjectArg != nullptr &&
       !isInitializingVariableImmutable(*ObjectArg, BlockStmt, Context))
     return;
 
   auto Diagnostic =
       diag(Var.getLocation(),
-           IsConstQualified ? "the const qualified variable %0 is "
-                              "copy-constructed from a const reference; "
-                              "consider making it a const reference"
-                            : "the variable %0 is copy-constructed from a "
-                              "const reference but is only used as const "
-                              "reference; consider making it a const reference")
-      << &Var;
+           "the %select{|const qualified }0variable %1 is copy-constructed "
+           "from a const reference%select{ but is only used as const "
+           "reference|}0; consider making it a const reference")
+      << IsConstQualified << &Var;
   if (IssueFix)
     recordFixes(Var, Context, Diagnostic);
 }
 
 void UnnecessaryCopyInitialization::handleCopyFromLocalVar(
     const VarDecl &NewVar, const VarDecl &OldVar, const Stmt &BlockStmt,
     bool IssueFix, ASTContext &Context) {
   if (!isOnlyUsedAsConst(NewVar, BlockStmt, Context) ||

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
   }
 
   const size_t Index = std::find(Function->parameters().begin(),
                                  Function->parameters().end(), Param) -
                        Function->parameters().begin();
 
   auto Diag =
       diag(Param->getLocation(),
-           IsConstQualified ? "the const qualified parameter %0 is "
-                              "copied for each invocation; consider "
-                              "making it a reference"
-                            : "the parameter %0 is copied for each "
-                              "invocation but only used as a const reference; "
-                              "consider making it a const reference")
-      << paramNameOrIndex(Param->getName(), Index);
+           "the %select{|const qualified }0parameter %1 is copied for each "
+           "invocation%select{ but only used as a const reference|}0; consider "
+           "making it a %select{const |}0reference")
+      << IsConstQualified << paramNameOrIndex(Param->getName(), Index);
   // Do not propose fixes when:
   // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
   // 2. the function is virtual as it might break overrides
   // 3. the function is referenced outside of a call expression within the
   //    compilation unit as the signature change could introduce build errors.
   // 4. the function is an explicit template specialization.
   const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
   if (Param->getBeginLoc().isMacroID() || (Method && Method->isVirtual()) ||

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp

 //===--- SIMDIntrinsicsCheck.cpp - clang-tidy------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SIMDIntrinsicsCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Regex.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace portability {
 
void SIMDIntrinsicsCheck::check(const MatchFinder::MatchResult &Result) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     New = trySuggestX86(Old);
     break;
   }
 
   // We have found a std::simd replacement.
   if (!New.empty()) {
-    std::string Message;
     // If Suggest is true, give a P0214 alternative, otherwise point it out it
     // is non-portable.
     if (Suggest) {
-      Message = (Twine("'") + Old + "' can be replaced by " + New).str();
-      Message = llvm::Regex("\\$std").sub(Std, Message);
-      Message =
-          llvm::Regex("\\$simd").sub((Std.str() + "::simd").str(), Message);
+      static const llvm::Regex StdRegex("\\$std"), SimdRegex("\\$simd");
+      diag(Call->getExprLoc(), "'%0' can be replaced by %1")
+          << Old
+          << SimdRegex.sub(SmallString<32>({Std, "::simd"}),
+                           StdRegex.sub(Std, New));
     } else {
-      Message = (Twine("'") + Old + "' is a non-portable " +
-                 llvm::Triple::getArchTypeName(Arch) + " intrinsic function")
-                    .str();
+      diag("'%0' is a non-portable %1 intrinsic function")
+          << Old << llvm::Triple::getArchTypeName(Arch);
     }
-    diag(Call->getExprLoc(), Message);
   }
 }
 
 } // namespace portability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

std::string ReplStr = [&] {
       llvm::StringRef LocalConst = IsLocalConst ? "const " : "";
       llvm::StringRef LocalVol = IsLocalVolatile ? "volatile " : "";
       llvm::StringRef LocalRestrict = IsLocalRestrict ? "__restrict " : "";
       return (PtrConst + "auto *" + LocalConst + LocalVol + LocalRestrict)
           .str();
     }();
 
     DiagnosticBuilder Diag =
-        diag(FixitLoc, "'%0%1%2auto %3' can be declared as '%4%3'")
-        << (IsLocalConst ? "const " : "")
-        << (IsLocalVolatile ? "volatile " : "")
-        << (IsLocalRestrict ? "__restrict " : "") << Var->getName() << ReplStr;
+        diag(FixitLoc,
+             "'%select{|const }0%select{|volatile }1%select{|__restrict }2auto "
+             "%3' can be declared as '%4%3'")
+        << IsLocalConst << IsLocalVolatile << IsLocalRestrict << Var->getName()
+        << ReplStr;
 
     for (SourceRange &Range : RemoveQualifiersRange) {
       Diag << FixItHint::CreateRemoval(CharSourceRange::getCharRange(Range));
     }
 
     Diag << FixItHint::CreateReplacement(FixItRange, ReplStr);
     return;
   }
if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto_ptr")) {
     }
 
     if (llvm::Optional<SourceRange> TypeSpec =
             getTypeSpecifierLocation(Var, Result)) {
       if (TypeSpec->isInvalid() || TypeSpec->getBegin().isMacroID() ||
           TypeSpec->getEnd().isMacroID())
         return;
       SourceLocation InsertPos = TypeSpec->getBegin();
-      diag(InsertPos, "'auto *%0%1%2' can be declared as 'const auto *%0%1%2'")
-          << (Var->getType().isLocalConstQualified() ? "const " : "")
-          << (Var->getType().isLocalVolatileQualified() ? "volatile " : "")
-          << Var->getName() << FixItHint::CreateInsertion(InsertPos, "const ");
+      diag(InsertPos,
+           "'auto *%select{|const }0%select{|volatile }1%2' can be declared as "
+           "'const auto *%select{|const }0%select{|volatile }1%2'")
+          << Var->getType().isLocalConstQualified()
+          << Var->getType().isLocalVolatileQualified() << Var->getName()
+          << FixItHint::CreateInsertion(InsertPos, "const ");
     }
     return;
   }
   if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto_ref")) {
     if (!isPointerConst(Var->getType()))
       return; // Pointer isn't const, no need to add const qualifier.
     if (!isAutoPointerConst(Var->getType()))
       // Const isnt wrapped in the auto type, so must be declared explicitly.

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

static bool isViableLoop(const CXXForRangeStmt &S, ASTContext &Context) {
   return llvm::none_of(Matches, [&Mutations](auto &DeclRef) {
     // TODO: allow modifications of loop-local variables
     return Mutations.isMutated(
         DeclRef.template getNodeAs<DeclRefExpr>("decl_ref")->getDecl());
   });
 }
 
 void UseAnyOfAllOfCheck::check(const MatchFinder::MatchResult &Result) {
-  StringRef Ranges = getLangOpts().CPlusPlus20 ? "::ranges" : "";
 
   if (const auto *S = Result.Nodes.getNodeAs<CXXForRangeStmt>("any_of_loop")) {
     if (!isViableLoop(*S, *Result.Context))
       return;
 
-    diag(S->getForLoc(), "replace loop by 'std%0::any_of()'") << Ranges;
+    diag(S->getForLoc(), "replace loop by 'std%select{|::ranges}0::any_of()'")
+        << getLangOpts().CPlusPlus20;
   } else if (const auto *S =
                  Result.Nodes.getNodeAs<CXXForRangeStmt>("all_of_loop")) {
     if (!isViableLoop(*S, *Result.Context))
       return;
 
-    diag(S->getForLoc(), "replace loop by 'std%0::all_of()'") << Ranges;
+    diag(S->getForLoc(), "replace loop by 'std%select{|::ranges}0::all_of()'")
+        << getLangOpts().CPlusPlus20;
   }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/test/clang-tidy/checkers/misc-uniqueptr-reset-release.cpp

 
 void f() {
   std::unique_ptr<Foo> a, b;
   std::unique_ptr<Bar> c;
   std::unique_ptr<Foo> *x = &a;
   std::unique_ptr<Foo> *y = &b;
 
   a.reset(b.release());
-  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: prefer ptr1 = std::move(ptr2) over ptr1.reset(ptr2.release()) [misc-uniqueptr-reset-release]
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: prefer ptr = std::move(ptr2) over ptr.reset(ptr2.release()) [misc-uniqueptr-reset-release]
   // CHECK-FIXES: a = std::move(b);
   a.reset(c.release());
-  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: prefer ptr1 = std::move(ptr2)
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: prefer ptr = std::move(ptr2)
   // CHECK-FIXES: a = std::move(c);
   a.reset(Create().release());
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: prefer ptr = ReturnUnique() over ptr.reset(ReturnUnique().release()) [misc-uniqueptr-reset-release]
   // CHECK-FIXES: a = Create();
   x->reset(y->release());
-  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: prefer ptr1 = std::move(ptr2)
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: prefer ptr = std::move(ptr2)
   // CHECK-FIXES: *x = std::move(*y);
   Look().reset(Look().release());
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: prefer ptr1 = std::move(ptr2)
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: prefer ptr = std::move(ptr2)
   // CHECK-FIXES: Look() = std::move(Look());
   Get()->reset(Get()->release());
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: prefer ptr1 = std::move(ptr2)
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: prefer ptr = std::move(ptr2)
   // CHECK-FIXES: *Get() = std::move(*Get());
 
   std::unique_ptr<Bar, FooFunc> func_a, func_b;
   func_a.reset(func_b.release());
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: prefer ptr1 = std::move(ptr2)
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: prefer ptr = std::move(ptr2)
   // CHECK-FIXES: func_a = std::move(func_b);
 }
 
 void negatives() {
   std::unique_ptr<Foo> src;
   struct OtherDeleter {};
   std::unique_ptr<Foo, OtherDeleter> dest;
   dest.reset(src.release());
 
   std::unique_ptr<Bar, FooFunc> func_a;
   std::unique_ptr<Bar, BarFunc> func_b;
   func_a.reset(func_b.release());
 }