Feature/merge upstream 20210309

clang-tools-extra/clang-query/Query.cpp

@@ -48,8 +48,6 @@ bool HelpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
         "    AsIs                            "
         "Print and match the AST as clang sees it.  This mode is the "
         "default.\n"
-        "    IgnoreImplicitCastsAndParentheses  "
-        "Omit implicit casts and parens in matching and dumping.\n"
         "    IgnoreUnlessSpelledInSource     "
         "Omit AST nodes unless spelled in the source.\n"
         "  set output <feature>              "

clang-tools-extra/clang-query/tool/ClangQuery.cpp

@@ -33,10 +33,10 @@
 #include "clang/Tooling/Tooling.h"
 #include "llvm/LineEditor/LineEditor.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/WithColor.h"
-#include <fstream>
 #include <string>
 
 using namespace clang;
@@ -73,16 +73,15 @@ static cl::opt<std::string> PreloadFile(
 
 bool runCommandsInFile(const char *ExeName, std::string const &FileName,
                        QuerySession &QS) {
-  std::ifstream Input(FileName.c_str());
-  if (!Input.is_open()) {
-    llvm::errs() << ExeName << ": cannot open " << FileName << "\n";
-    return 1;
+  auto Buffer = llvm::MemoryBuffer::getFile(FileName);
+  if (!Buffer) {
+    llvm::errs() << ExeName << ": cannot open " << FileName << ": "
+                 << Buffer.getError().message() << "\n";
+    return true;
   }
 
-  std::string FileContent((std::istreambuf_iterator<char>(Input)),
-                          std::istreambuf_iterator<char>());
+  StringRef FileContentRef(Buffer.get()->getBuffer());
 
-  StringRef FileContentRef(FileContent);
   while (!FileContentRef.empty()) {
     QueryRef Q = QueryParser::parse(FileContentRef, QS);
     if (!Q->run(llvm::outs(), QS))

clang-tools-extra/clang-tidy/ClangTidy.cpp

@@ -393,6 +393,10 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks =
       CheckFactories->createChecks(&Context);
 
+  llvm::erase_if(Checks, [&](std::unique_ptr<ClangTidyCheck> &Check) {
+    return !Check->isLanguageVersionSupported(Context.getLangOpts());
+  });
+
   ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
 
   std::unique_ptr<ClangTidyProfiling> Profiling;
@@ -416,8 +420,6 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
   }
 
   for (auto &Check : Checks) {
-    if (!Check->isLanguageVersionSupported(Context.getLangOpts()))
-      continue;
     Check->registerMatchers(&*Finder);
     Check->registerPPCallbacks(*SM, PP, ModuleExpanderPP);
   }

clang-tools-extra/clang-tidy/altera/StructPackAlignCheck.cpp

@@ -11,7 +11,6 @@
 #include "clang/AST/RecordLayout.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include <math.h>
-#include <sstream>
 
 using namespace clang::ast_matchers;
 
@@ -109,15 +108,13 @@ void StructPackAlignCheck::check(const MatchFinder::MatchResult &Result) {
   AlignedAttr *Attribute = Struct->getAttr<AlignedAttr>();
   std::string NewAlignQuantity = std::to_string((int)NewAlign.getQuantity());
   if (Attribute) {
-    std::ostringstream FixItString;
-    FixItString << "aligned(" << NewAlignQuantity << ")";
-    FixIt =
-        FixItHint::CreateReplacement(Attribute->getRange(), FixItString.str());
+    FixIt = FixItHint::CreateReplacement(
+        Attribute->getRange(),
+        (Twine("aligned(") + NewAlignQuantity + ")").str());
   } else {
-    std::ostringstream FixItString;
-    FixItString << " __attribute__((aligned(" << NewAlignQuantity << ")))";
-    FixIt = FixItHint::CreateInsertion(Struct->getEndLoc().getLocWithOffset(1),
-                                       FixItString.str());
+    FixIt = FixItHint::CreateInsertion(
+        Struct->getEndLoc().getLocWithOffset(1),
+        (Twine(" __attribute__((aligned(") + NewAlignQuantity + ")))").str());
   }
 
   // And suggest the minimum power-of-two alignment for the struct as a whole

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

@@ -25,25 +25,37 @@ AST_MATCHER(CXXRecordDecl, hasNonTrivialDestructor) {
 
 void UnusedRaiiCheck::registerMatchers(MatchFinder *Finder) {
   // Look for temporaries that are constructed in-place and immediately
-  // destroyed. Look for temporaries created by a functional cast but not for
-  // those returned from a call.
-  auto BindTemp = cxxBindTemporaryExpr(
-                      unless(has(ignoringParenImpCasts(callExpr()))),
-                      unless(has(ignoringParenImpCasts(objcMessageExpr()))))
-                      .bind("temp");
+  // destroyed.
   Finder->addMatcher(
-      traverse(TK_AsIs,
-               exprWithCleanups(
-                   unless(isInTemplateInstantiation()),
-                   hasParent(compoundStmt().bind("compound")),
-                   hasType(cxxRecordDecl(hasNonTrivialDestructor())),
-                   anyOf(has(ignoringParenImpCasts(BindTemp)),
-                         has(ignoringParenImpCasts(cxxFunctionalCastExpr(
-                             has(ignoringParenImpCasts(BindTemp)))))))
-                   .bind("expr")),
+      mapAnyOf(cxxConstructExpr, cxxUnresolvedConstructExpr)
+          .with(hasParent(compoundStmt().bind("compound")),
+                anyOf(hasType(cxxRecordDecl(hasNonTrivialDestructor())),
+                      hasType(templateSpecializationType(
+                          hasDeclaration(classTemplateDecl(has(
+                              cxxRecordDecl(hasNonTrivialDestructor()))))))))
+          .bind("expr"),
       this);
 }
 
+template <typename T>
+void reportDiagnostic(DiagnosticBuilder D, const T *Node, SourceRange SR,
+                      bool DefaultConstruction) {
+  const char *Replacement = " give_me_a_name";
+
+  // If this is a default ctor we have to remove the parens or we'll introduce a
+  // most vexing parse.
+  if (DefaultConstruction) {
+    D << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(SR),
+                                      Replacement);
+    return;
+  }
+
+  // Otherwise just suggest adding a name. To find the place to insert the name
+  // find the first TypeLoc in the children of E, which always points to the
+  // written type.
+  D << FixItHint::CreateInsertion(SR.getBegin(), Replacement);
+}
+
 void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
 
@@ -55,35 +67,32 @@ void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
   // Don't emit a warning for the last statement in the surrounding compound
   // statement.
   const auto *CS = Result.Nodes.getNodeAs<CompoundStmt>("compound");
-  if (E == CS->body_back())
+  const auto *LastExpr = dyn_cast<Expr>(CS->body_back());
+
+  if (LastExpr && E == LastExpr->IgnoreUnlessSpelledInSource())
     return;
 
   // Emit a warning.
   auto D = diag(E->getBeginLoc(), "object destroyed immediately after "
                                   "creation; did you mean to name the object?");
-  const char *Replacement = " give_me_a_name";
 
-  // If this is a default ctor we have to remove the parens or we'll introduce a
-  // most vexing parse.
-  const auto *BTE = Result.Nodes.getNodeAs<CXXBindTemporaryExpr>("temp");
-  if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(BTE->getSubExpr()))
-    if (TOE->getNumArgs() == 0) {
-      D << FixItHint::CreateReplacement(
-          CharSourceRange::getTokenRange(TOE->getParenOrBraceRange()),
-          Replacement);
-      return;
+  if (const auto *Node = dyn_cast<CXXConstructExpr>(E))
+    reportDiagnostic(D, Node, Node->getParenOrBraceRange(),
+                     Node->getNumArgs() == 0 ||
+                         isa<CXXDefaultArgExpr>(Node->getArg(0)));
+  if (const auto *Node = dyn_cast<CXXUnresolvedConstructExpr>(E)) {
+    auto SR = SourceRange(Node->getLParenLoc(), Node->getRParenLoc());
+    auto DefaultConstruction = Node->getNumArgs() == 0;
+    if (!DefaultConstruction) {
+      auto FirstArg = Node->getArg(0);
+      DefaultConstruction = isa<CXXDefaultArgExpr>(FirstArg);
+      if (auto ILE = dyn_cast<InitListExpr>(FirstArg)) {
+        DefaultConstruction = ILE->getNumInits() == 0;
+        SR = SourceRange(ILE->getLBraceLoc(), ILE->getRBraceLoc());
+      }
     }
-
-  // Otherwise just suggest adding a name. To find the place to insert the name
-  // find the first TypeLoc in the children of E, which always points to the
-  // written type.
-  auto Matches =
-      match(expr(hasDescendant(typeLoc().bind("t"))), *E, *Result.Context);
-  if (const auto *TL = selectFirst<TypeLoc>("t", Matches))
-    D << FixItHint::CreateInsertion(
-        Lexer::getLocForEndOfToken(TL->getEndLoc(), 0, *Result.SourceManager,
-                                   getLangOpts()),
-        Replacement);
+    reportDiagnostic(D, Node, SR, DefaultConstruction);
+  }
 }
 
 } // namespace bugprone

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

@@ -28,6 +28,9 @@ class UnusedRaiiCheck : public ClangTidyCheck {
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 };
 
 } // namespace bugprone

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

@@ -398,7 +398,13 @@ void UseAfterMoveCheck::registerMatchers(MatchFinder *Finder) {
                hasArgument(0, declRefExpr().bind("arg")),
                anyOf(hasAncestor(lambdaExpr().bind("containing-lambda")),
                      hasAncestor(functionDecl().bind("containing-func"))),
-               unless(inDecltypeOrTemplateArg()))
+               unless(inDecltypeOrTemplateArg()),
+               // try_emplace is a common maybe-moving function that returns a
+               // bool to tell callers whether it moved. Ignore std::move inside
+               // try_emplace to avoid false positives as we don't track uses of
+               // the bool.
+               unless(hasParent(cxxMemberCallExpr(
+                   callee(cxxMethodDecl(hasName("try_emplace")))))))
           .bind("call-move");
 
   Finder->addMatcher(