drop base pr

Created using spr 1.3.5-bogner

Author: MaskRay

.mailmap

@@ -29,7 +29,8 @@
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
-<[email protected]> <[email protected]>
+Min Hsu <[email protected]> <[email protected]>
+Min Hsu <[email protected]> <[email protected]>
 <[email protected]> <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>

bolt/lib/Core/BinaryContext.cpp

@@ -663,6 +663,7 @@ bool BinaryContext::analyzeJumpTable(const uint64_t Address,
     const BinaryFunction *TargetBF = getBinaryFunctionContainingAddress(Value);
     if (!TargetBF || !areRelatedFragments(TargetBF, &BF)) {
       LLVM_DEBUG(printEntryDiagnostics(dbgs(), TargetBF));
+      (void)printEntryDiagnostics;
       break;
     }
 
@@ -843,6 +844,7 @@ BinaryContext::getOrCreateJumpTable(BinaryFunction &Function, uint64_t Address,
                                &Function, std::placeholders::_1);
     assert(llvm::all_of(JT->Parents, isSibling) &&
            "cannot re-use jump table of a different function");
+    (void)isSibling;
     if (opts::Verbosity > 2) {
       this->outs() << "BOLT-INFO: multiple fragments access the same jump table"
                    << ": " << *JT->Parents[0] << "; " << Function << '\n';

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

@@ -7,6 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "UnintendedCharOstreamOutputCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
@@ -35,10 +37,14 @@ AST_MATCHER(Type, isChar) {
 
 UnintendedCharOstreamOutputCheck::UnintendedCharOstreamOutputCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), CastTypeName(Options.get("CastTypeName")) {
-}
+    : ClangTidyCheck(Name, Context),
+      AllowedTypes(utils::options::parseStringList(
+          Options.get("AllowedTypes", "unsigned char;signed char"))),
+      CastTypeName(Options.get("CastTypeName")) {}
 void UnintendedCharOstreamOutputCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "AllowedTypes",
+                utils::options::serializeStringList(AllowedTypes));
   if (CastTypeName.has_value())
     Options.store(Opts, "CastTypeName", CastTypeName.value());
 }
@@ -50,13 +56,20 @@ void UnintendedCharOstreamOutputCheck::registerMatchers(MatchFinder *Finder) {
                     // with char / unsigned char / signed char
                     classTemplateSpecializationDecl(
                         hasTemplateArgument(0, refersToType(isChar()))));
+  auto IsDeclRefExprFromAllowedTypes = declRefExpr(to(varDecl(
+      hasType(matchers::matchesAnyListedTypeName(AllowedTypes, false)))));
+  auto IsExplicitCastExprFromAllowedTypes = explicitCastExpr(hasDestinationType(
+      matchers::matchesAnyListedTypeName(AllowedTypes, false)));
   Finder->addMatcher(
       cxxOperatorCallExpr(
           hasOverloadedOperatorName("<<"),
           hasLHS(hasType(hasUnqualifiedDesugaredType(
               recordType(hasDeclaration(cxxRecordDecl(
                   anyOf(BasicOstream, isDerivedFrom(BasicOstream)))))))),
-          hasRHS(hasType(hasUnqualifiedDesugaredType(isNumericChar()))))
+          hasRHS(expr(hasType(hasUnqualifiedDesugaredType(isNumericChar())),
+                      unless(ignoringParenImpCasts(
+                          anyOf(IsDeclRefExprFromAllowedTypes,
+                                IsExplicitCastExprFromAllowedTypes))))))
           .bind("x"),
       this);
 }

clang-tools-extra/clang-tidy/bugprone/UnintendedCharOstreamOutputCheck.h

@@ -30,6 +30,7 @@ class UnintendedCharOstreamOutputCheck : public ClangTidyCheck {
   }
 
 private:
+  const std::vector<StringRef> AllowedTypes;
   const std::optional<StringRef> CastTypeName;
 };
 

clang-tools-extra/clang-tidy/utils/Matchers.cpp

@@ -18,8 +18,9 @@ bool NotIdenticalStatementsPredicate::operator()(
 }
 
 MatchesAnyListedTypeNameMatcher::MatchesAnyListedTypeNameMatcher(
-    llvm::ArrayRef<StringRef> NameList)
-    : NameMatchers(NameList.begin(), NameList.end()) {}
+    llvm::ArrayRef<StringRef> NameList, bool CanonicalTypes)
+    : NameMatchers(NameList.begin(), NameList.end()),
+      CanonicalTypes(CanonicalTypes) {}
 
 MatchesAnyListedTypeNameMatcher::~MatchesAnyListedTypeNameMatcher() = default;
 
@@ -32,7 +33,7 @@ bool MatchesAnyListedTypeNameMatcher::matches(
 
   PrintingPolicy PrintingPolicyWithSuppressedTag(
       Finder->getASTContext().getLangOpts());
-  PrintingPolicyWithSuppressedTag.PrintCanonicalTypes = true;
+  PrintingPolicyWithSuppressedTag.PrintCanonicalTypes = CanonicalTypes;
   PrintingPolicyWithSuppressedTag.SuppressElaboration = true;
   PrintingPolicyWithSuppressedTag.SuppressScope = false;
   PrintingPolicyWithSuppressedTag.SuppressTagKeyword = true;

clang-tools-extra/clang-tidy/utils/Matchers.h

@@ -172,21 +172,28 @@ AST_MATCHER_P(Stmt, isStatementIdenticalToBoundNode, std::string, ID) {
 class MatchesAnyListedTypeNameMatcher
     : public ast_matchers::internal::MatcherInterface<QualType> {
 public:
-  explicit MatchesAnyListedTypeNameMatcher(llvm::ArrayRef<StringRef> NameList);
+  explicit MatchesAnyListedTypeNameMatcher(llvm::ArrayRef<StringRef> NameList,
+                                           bool CanonicalTypes);
   ~MatchesAnyListedTypeNameMatcher() override;
   bool matches(
       const QualType &Node, ast_matchers::internal::ASTMatchFinder *Finder,
       ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override;
 
 private:
   std::vector<llvm::Regex> NameMatchers;
+  bool CanonicalTypes;
 };
 
 // Returns a matcher that matches QualType against a list of provided regular.
 inline ::clang::ast_matchers::internal::Matcher<QualType>
-matchesAnyListedTypeName(llvm::ArrayRef<StringRef> NameList) {
+matchesAnyListedTypeName(llvm::ArrayRef<StringRef> NameList,
+                         bool CanonicalTypes) {
   return ::clang::ast_matchers::internal::makeMatcher(
-      new MatchesAnyListedTypeNameMatcher(NameList));
+      new MatchesAnyListedTypeNameMatcher(NameList, CanonicalTypes));
+}
+inline ::clang::ast_matchers::internal::Matcher<QualType>
+matchesAnyListedTypeName(llvm::ArrayRef<StringRef> NameList) {
+  return matchesAnyListedTypeName(NameList, true);
 }
 
 } // namespace clang::tidy::matchers

clang-tools-extra/clangd/AST.cpp

@@ -439,7 +439,8 @@ QualType declaredType(const TypeDecl *D) {
   if (const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(D))
     if (const auto *Args = CTSD->getTemplateArgsAsWritten())
       return Context.getTemplateSpecializationType(
-          TemplateName(CTSD->getSpecializedTemplate()), Args->arguments());
+          TemplateName(CTSD->getSpecializedTemplate()), Args->arguments(),
+          /*CanonicalArgs=*/std::nullopt);
   return Context.getTypeDeclType(D);
 }
 

clang-tools-extra/docs/clang-tidy/checks/bugprone/unintended-char-ostream-output.rst

@@ -42,6 +42,16 @@ Or cast to char to explicitly indicate that output should be a character.
 Options
 -------
 
+.. option:: AllowedTypes
+
+  A semicolon-separated list of type names that will be treated like the ``char``
+  type: the check will not report variables declared with with these types or
+  explicit cast expressions to these types. Note that this distinguishes type
+  aliases from the original type, so specifying e.g. ``unsigned char`` here
+  will not suppress reports about ``uint8_t`` even if it is defined as a
+  ``typedef`` alias for ``unsigned char``.
+  Default is `unsigned char;signed char`.
+
 .. option:: CastTypeName
 
   When `CastTypeName` is specified, the fix-it will use `CastTypeName` as the

clang-tools-extra/test/clang-doc/Inputs/basic-project/include/Calculator.h

@@ -43,4 +43,25 @@ class Calculator {
      * @throw std::invalid_argument if b is zero.
      */
     double divide(int a, int b);
-};
+
+    /**
+     * @brief Performs the mod operation on integers.
+     *
+     * @param a First integer.
+     * @param b Second integer.
+     * @return The result of a % b.
+     */
+    static int mod(int a, int b) {
+      return a % b;
+    }
+
+    /**
+     * @brief A static value.
+     */
+    static constexpr int static_val = 10;
+
+    /**
+     * @brief Holds a public value.
+     */
+    int public_val = -1;
+};

clang-tools-extra/test/clang-doc/Inputs/basic-project/src/Calculator.cpp

@@ -15,3 +15,4 @@ int Calculator::multiply(int a, int b) {
 double Calculator::divide(int a, int b) {
   return static_cast<double>(a) / b;
 }
+