Merge remote-tracking branch 'origin/sycl' into fork_l0_plugin

Author: againull

README.md

@@ -22,7 +22,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 ## Sub-projects Documentation
 
 * oneAPI Data Parallel C++ compiler - See
-  [GetStartedGuide.md](sycl/doc/GetStartedGuide.md)
+  [DPC++ Documentation](https://intel.github.io/llvm-docs/)
 
 ## DPC++ extensions
 

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

@@ -43,6 +43,15 @@ bool HelpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
         "Set whether to bind the root matcher to \"root\".\n"
         "  set print-matcher (true|false)    "
         "Set whether to print the current matcher,\n"
+        "  set traversal <kind>              "
+        "Set traversal kind of clang-query session. Available kinds are:\n"
+        "    AsIs                            "
+        "Print and match the AST as clang sees it.\n"
+        "    IgnoreImplicitCastsAndParentheses  "
+        "Omit implicit casts and parens in matching and dumping.\n"
+        "    IgnoreUnlessSpelledInSource     "
+        "Omit AST nodes unless spelled in the source.  This mode is the "
+        "default.\n"
         "  set output <feature>              "
         "Set whether to output only <feature> content.\n"
         "  enable output <feature>           "
@@ -98,6 +107,8 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
       OS << "Not a valid top-level matcher.\n";
       return false;
     }
+
+    AST->getASTContext().getParentMapContext().setTraversalKind(QS.TK);
     Finder.matchAST(AST->getASTContext());
 
     if (QS.PrintMatcher) {
@@ -148,6 +159,7 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
           const SourceManager &SM = Ctx.getSourceManager();
           ASTDumper Dumper(OS, &Ctx.getCommentCommandTraits(), &SM,
                 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
+          Dumper.SetTraversalKind(QS.TK);
           Dumper.Visit(BI->second);
           OS << "\n";
         }

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

@@ -28,6 +28,7 @@ enum QueryKind {
   QK_Match,
   QK_SetBool,
   QK_SetOutputKind,
+  QK_SetTraversalKind,
   QK_EnableOutputKind,
   QK_DisableOutputKind,
   QK_Quit
@@ -119,6 +120,10 @@ template <> struct SetQueryKind<OutputKind> {
   static const QueryKind value = QK_SetOutputKind;
 };
 
+template <> struct SetQueryKind<ast_type_traits::TraversalKind> {
+  static const QueryKind value = QK_SetTraversalKind;
+};
+
 /// Query for "set VAR VALUE".
 template <typename T> struct SetQuery : Query {
   SetQuery(T QuerySession::*Var, T Value)

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

@@ -128,6 +128,24 @@ template <typename QueryType> QueryRef QueryParser::parseSetOutputKind() {
   llvm_unreachable("Invalid output kind");
 }
 
+QueryRef QueryParser::parseSetTraversalKind(
+    ast_type_traits::TraversalKind QuerySession::*Var) {
+  StringRef ValStr;
+  unsigned Value =
+      LexOrCompleteWord<unsigned>(this, ValStr)
+          .Case("AsIs", ast_type_traits::TK_AsIs)
+          .Case("IgnoreImplicitCastsAndParentheses",
+                ast_type_traits::TK_IgnoreImplicitCastsAndParentheses)
+          .Case("IgnoreUnlessSpelledInSource",
+                ast_type_traits::TK_IgnoreUnlessSpelledInSource)
+          .Default(~0u);
+  if (Value == ~0u) {
+    return new InvalidQuery("expected traversal kind, got '" + ValStr + "'");
+  }
+  return new SetQuery<ast_type_traits::TraversalKind>(
+      Var, static_cast<ast_type_traits::TraversalKind>(Value));
+}
+
 QueryRef QueryParser::endQuery(QueryRef Q) {
   StringRef Extra = Line;
   StringRef ExtraTrimmed = Extra.drop_while(
@@ -171,7 +189,8 @@ enum ParsedQueryVariable {
   PQV_Invalid,
   PQV_Output,
   PQV_BindRoot,
-  PQV_PrintMatcher
+  PQV_PrintMatcher,
+  PQV_Traversal
 };
 
 QueryRef makeInvalidQueryFromDiagnostics(const Diagnostics &Diag) {
@@ -272,6 +291,7 @@ QueryRef QueryParser::doParse() {
             .Case("output", PQV_Output)
             .Case("bind-root", PQV_BindRoot)
             .Case("print-matcher", PQV_PrintMatcher)
+            .Case("traversal", PQV_Traversal)
             .Default(PQV_Invalid);
     if (VarStr.empty())
       return new InvalidQuery("expected variable name");
@@ -289,6 +309,9 @@ QueryRef QueryParser::doParse() {
     case PQV_PrintMatcher:
       Q = parseSetBool(&QuerySession::PrintMatcher);
       break;
+    case PQV_Traversal:
+      Q = parseSetTraversalKind(&QuerySession::TK);
+      break;
     case PQV_Invalid:
       llvm_unreachable("Invalid query kind");
     }

clang-tools-extra/clang-query/QueryParser.h

@@ -43,6 +43,8 @@ class QueryParser {
   template <typename T> struct LexOrCompleteWord;
 
   QueryRef parseSetBool(bool QuerySession::*Var);
+  QueryRef
+  parseSetTraversalKind(ast_type_traits::TraversalKind QuerySession::*Var);
   template <typename QueryType> QueryRef parseSetOutputKind();
   QueryRef completeMatcherExpression();
 

clang-tools-extra/clang-query/QuerySession.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 
+#include "clang/AST/ASTTypeTraits.h"
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringMap.h"
@@ -25,7 +26,7 @@ class QuerySession {
   QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
       : ASTs(ASTs), PrintOutput(false), DiagOutput(true),
         DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
-        Terminate(false) {}
+        Terminate(false), TK(ast_type_traits::TK_IgnoreUnlessSpelledInSource) {}
 
   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
 
@@ -36,6 +37,8 @@ class QuerySession {
   bool BindRoot;
   bool PrintMatcher;
   bool Terminate;
+
+  ast_type_traits::TraversalKind TK;
   llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 

clang-tools-extra/clang-reorder-fields/ReorderFieldsAction.cpp

@@ -104,9 +104,11 @@ findMembersUsedInInitExpr(const CXXCtorInitializer *Initializer,
   // for those accesses Sema::PerformObjectMemberConversion always inserts an
   // UncheckedDerivedToBase ImplicitCastExpr between the this expr and the
   // object expression
-  auto FoundExprs =
-      match(findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME")),
-            *Initializer->getInit(), Context);
+  auto FoundExprs = match(
+      traverse(
+          TK_AsIs,
+          findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME"))),
+      *Initializer->getInit(), Context);
   for (BoundNodes &BN : FoundExprs)
     if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME"))
       if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl()))

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

@@ -20,16 +20,17 @@ void DurationDivisionCheck::registerMatchers(MatchFinder *finder) {
   const auto DurationExpr =
       expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))));
   finder->addMatcher(
-      implicitCastExpr(
-          hasSourceExpression(ignoringParenCasts(
-              cxxOperatorCallExpr(hasOverloadedOperatorName("/"),
-                                  hasArgument(0, DurationExpr),
-                                  hasArgument(1, DurationExpr))
-                  .bind("OpCall"))),
-          hasImplicitDestinationType(qualType(unless(isInteger()))),
-          unless(hasParent(cxxStaticCastExpr())),
-          unless(hasParent(cStyleCastExpr())),
-          unless(isInTemplateInstantiation())),
+      traverse(ast_type_traits::TK_AsIs,
+               implicitCastExpr(
+                   hasSourceExpression(ignoringParenCasts(
+                       cxxOperatorCallExpr(hasOverloadedOperatorName("/"),
+                                           hasArgument(0, DurationExpr),
+                                           hasArgument(1, DurationExpr))
+                           .bind("OpCall"))),
+                   hasImplicitDestinationType(qualType(unless(isInteger()))),
+                   unless(hasParent(cxxStaticCastExpr())),
+                   unless(hasParent(cStyleCastExpr())),
+                   unless(isInTemplateInstantiation()))),
       this);
 }
 

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

@@ -78,20 +78,23 @@ void FasterStrsplitDelimiterCheck::registerMatchers(MatchFinder *Finder) {
 
   // Find uses of absl::StrSplit(..., "x") and absl::StrSplit(...,
   // absl::ByAnyChar("x")) to transform them into absl::StrSplit(..., 'x').
-  Finder->addMatcher(callExpr(callee(functionDecl(hasName("::absl::StrSplit"))),
-                              hasArgument(1, anyOf(ByAnyCharArg, SingleChar)),
-                              unless(isInTemplateInstantiation()))
-                         .bind("StrSplit"),
-                     this);
+  Finder->addMatcher(
+      traverse(ast_type_traits::TK_AsIs,
+               callExpr(callee(functionDecl(hasName("::absl::StrSplit"))),
+                        hasArgument(1, anyOf(ByAnyCharArg, SingleChar)),
+                        unless(isInTemplateInstantiation()))
+                   .bind("StrSplit")),
+      this);
 
   // Find uses of absl::MaxSplits("x", N) and
   // absl::MaxSplits(absl::ByAnyChar("x"), N) to transform them into
   // absl::MaxSplits('x', N).
   Finder->addMatcher(
-      callExpr(
-          callee(functionDecl(hasName("::absl::MaxSplits"))),
-          hasArgument(0, anyOf(ByAnyCharArg, ignoringParenCasts(SingleChar))),
-          unless(isInTemplateInstantiation())),
+      traverse(ast_type_traits::TK_AsIs,
+               callExpr(callee(functionDecl(hasName("::absl::MaxSplits"))),
+                        hasArgument(0, anyOf(ByAnyCharArg,
+                                             ignoringParenCasts(SingleChar))),
+                        unless(isInTemplateInstantiation()))),
       this);
 }
 

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

@@ -64,11 +64,12 @@ const clang::CallExpr* ProcessArgument(const Expr* Arg,
   static const auto* const Strcat = new auto(hasName("::absl::StrCat"));
   const auto IsStrcat = cxxBindTemporaryExpr(
       has(callExpr(callee(functionDecl(*Strcat))).bind("StrCat")));
-  if (const auto* SubStrcatCall = selectFirst<const CallExpr>(
+  if (const auto *SubStrcatCall = selectFirst<const CallExpr>(
           "StrCat",
-          match(stmt(anyOf(
-                    cxxConstructExpr(IsAlphanum, hasArgument(0, IsStrcat)),
-                    IsStrcat)),
+          match(stmt(traverse(ast_type_traits::TK_AsIs,
+                              anyOf(cxxConstructExpr(IsAlphanum,
+                                                     hasArgument(0, IsStrcat)),
+                                    IsStrcat))),
                 *Arg->IgnoreParenImpCasts(), *Result.Context))) {
     RemoveCallLeaveArgs(SubStrcatCall, CheckResult);
     return SubStrcatCall;