Merge from 'main' to 'sycl-web' (intel#67)

  CONFLICT (content): Merge conflict in clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp

Author: Pavel V Chupin

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

@@ -49,11 +49,76 @@ AST_MATCHER_FUNCTION(ast_matchers::TypeMatcher, isPointerToConst) {
   return pointerType(pointee(qualType(isConstQualified())));
 }
 
-AST_MATCHER_P(NamedDecl, matchesAnyListedName, std::vector<std::string>,
-              NameList) {
-  return llvm::any_of(NameList, [&Node](const std::string &Name) {
-      return llvm::Regex(Name).match(Node.getName());
+// A matcher implementation that matches a list of type name regular expressions
+// against a NamedDecl. If a regular expression contains the substring "::"
+// matching will occur against the qualified name, otherwise only the typename.
+class MatchesAnyListedNameMatcher
+    : public ast_matchers::internal::MatcherInterface<NamedDecl> {
+public:
+  explicit MatchesAnyListedNameMatcher(llvm::ArrayRef<std::string> NameList) {
+    std::transform(
+        NameList.begin(), NameList.end(), std::back_inserter(NameMatchers),
+        [](const llvm::StringRef Name) { return NameMatcher(Name); });
+  }
+  bool matches(
+      const NamedDecl &Node, ast_matchers::internal::ASTMatchFinder *Finder,
+      ast_matchers::internal::BoundNodesTreeBuilder *Builder) const override {
+    return llvm::any_of(NameMatchers, [&Node](const NameMatcher &NM) {
+      return NM.match(Node);
     });
+  }
+
+private:
+  class NameMatcher {
+    llvm::Regex Regex;
+    enum class MatchMode {
+      // Match against the unqualified name because the regular expression
+      // does not contain ":".
+      MatchUnqualified,
+      // Match against the qualified name because the regular expression
+      // contains ":" suggesting name and namespace should be matched.
+      MatchQualified,
+      // Match against the fully qualified name because the regular expression
+      // starts with ":".
+      MatchFullyQualified,
+    };
+    MatchMode Mode;
+
+  public:
+    NameMatcher(const llvm::StringRef Regex)
+        : Regex(Regex), Mode(determineMatchMode(Regex)) {}
+
+    bool match(const NamedDecl &ND) const {
+      switch (Mode) {
+      case MatchMode::MatchQualified:
+        return Regex.match(ND.getQualifiedNameAsString());
+      case MatchMode::MatchFullyQualified:
+        return Regex.match("::" + ND.getQualifiedNameAsString());
+      default:
+        return Regex.match(ND.getName());
+      }
+    }
+
+  private:
+    MatchMode determineMatchMode(llvm::StringRef Regex) {
+      if (Regex.startswith(":") || Regex.startswith("^:")) {
+        return MatchMode::MatchFullyQualified;
+      }
+      return Regex.contains(":") ? MatchMode::MatchQualified
+                                 : MatchMode::MatchUnqualified;
+    }
+  };
+
+  std::vector<NameMatcher> NameMatchers;
+};
+
+// Returns a matcher that matches NamedDecl's against a list of provided regular
+// expressions. If a regular expression contains starts ':' the NamedDecl's
+// qualified name will be used for matching, otherwise its name will be used.
+inline ::clang::ast_matchers::internal::Matcher<NamedDecl>
+matchesAnyListedName(llvm::ArrayRef<std::string> NameList) {
+  return ::clang::ast_matchers::internal::makeMatcher(
+      new MatchesAnyListedNameMatcher(NameList));
 }
 
 } // namespace matchers

clang-tools-extra/clangd/Compiler.cpp

@@ -118,9 +118,7 @@ prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI,
     VFS = VFSWithRemapping;
   Clang->createFileManager(VFS);
 
-  Clang->setTarget(TargetInfo::CreateTargetInfo(
-      Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
-  if (!Clang->hasTarget())
+  if (!Clang->createTarget())
     return nullptr;
 
   // RemappedFileBuffers will handle the lifetime of the Buffer pointer,

clang-tools-extra/docs/clang-tidy/checks/bugprone-misplaced-widening-cast.rst

@@ -62,4 +62,4 @@ Options
 
 .. option:: CheckImplicitCasts
 
-   If `true`, enables detection of implicit casts. Default is `true`.
+   If `true`, enables detection of implicit casts. Default is `false`.

clang-tools-extra/docs/clang-tidy/checks/performance-for-range-copy.rst

@@ -31,4 +31,6 @@ Options
    A semicolon-separated list of names of types allowed to be copied in each
    iteration. Regular expressions are accepted, e.g. `[Rr]ef(erence)?$` matches
    every type with suffix `Ref`, `ref`, `Reference` and `reference`. The default
-   is empty.
+   is empty. If a name in the list contains the sequence `::` it is matched
+   against the qualified typename (i.e. `namespace::Type`, otherwise it is
+   matched against only the type name (i.e. `Type`).

clang-tools-extra/docs/clang-tidy/checks/performance-unnecessary-copy-initialization.rst

@@ -43,5 +43,7 @@ Options
 
    A semicolon-separated list of names of types allowed to be initialized by
    copying. Regular expressions are accepted, e.g. `[Rr]ef(erence)?$` matches
-   every type with suffix `Ref`, `ref`, `Reference` and `reference`. The
-   default is empty.
+   every type with suffix `Ref`, `ref`, `Reference` and `reference`. The default
+   is empty. If a name in the list contains the sequence `::` it is matched
+   against the qualified typename (i.e. `namespace::Type`, otherwise it is
+   matched against only the type name (i.e. `Type`).

clang-tools-extra/docs/clang-tidy/checks/performance-unnecessary-value-param.rst

@@ -66,4 +66,7 @@ Options
 
    A semicolon-separated list of names of types allowed to be passed by value.
    Regular expressions are accepted, e.g. `[Rr]ef(erence)?$` matches every type
-   with suffix `Ref`, `ref`, `Reference` and `reference`. The default is empty.
+   with suffix `Ref`, `ref`, `Reference` and `reference`. The default is
+   empty. If a name in the list contains the sequence `::` it is matched against
+   the qualified typename (i.e. `namespace::Type`, otherwise it is matched
+   against only the type name (i.e. `Type`).

clang-tools-extra/test/clang-tidy/checkers/performance-for-range-copy-allowed-types.cpp

@@ -1,5 +1,5 @@
 // RUN: %check_clang_tidy %s performance-for-range-copy %t -- \
-// RUN:     -config="{CheckOptions: [{key: performance-for-range-copy.AllowedTypes, value: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}]}" \
+// RUN:     -config="{CheckOptions: [{key: performance-for-range-copy.AllowedTypes, value: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$;qualified::Type;::fully::QualifiedType'}]}" \
 // RUN:     -- -fno-delayed-template-parsing
 
 template <typename T>
@@ -63,6 +63,18 @@ template <typename T> struct SomeComplexTemplate {
 
 typedef SomeComplexTemplate<int> NotTooComplexRef;
 
+namespace qualified {
+struct Type {
+  ~Type();
+};
+} // namespace qualified
+
+namespace fully {
+struct QualifiedType {
+  ~QualifiedType();
+};
+} // namespace fully
+
 void negativeSmartPointer() {
   for (auto P : View<Iterator<SmartPointer>>()) {
     auto P2 = P;
@@ -124,3 +136,23 @@ void negativeNotTooComplexRef() {
     auto R2 = R;
   }
 }
+
+void negativeQualified() {
+  for (auto Q : View<Iterator<qualified::Type>>()) {
+    auto Q2 = Q;
+  }
+  using qualified::Type;
+  for (auto Q : View<Iterator<Type>>()) {
+    auto Q2 = Q;
+  }
+}
+
+void negativeFullyQualified() {
+  for (auto Q : View<Iterator<fully::QualifiedType>>()) {
+    auto Q2 = Q;
+  }
+  using fully::QualifiedType;
+  for (auto Q : View<Iterator<QualifiedType>>()) {
+    auto Q2 = Q;
+  }
+}

clang/include/clang/Basic/Builtins.def

@@ -1636,9 +1636,6 @@ LANGBUILTIN(__builtin_load_halff, "fhC*", "nc", ALL_OCLC_LANGUAGES)
 BUILTIN(__builtin_os_log_format_buffer_size, "zcC*.", "p:0:nut")
 BUILTIN(__builtin_os_log_format, "v*v*cC*.", "p:0:nt")
 
-// OpenMP 4.0
-LANGBUILTIN(omp_is_initial_device, "i", "nc", OMP_LANG)
-
 // CUDA/HIP
 LANGBUILTIN(__builtin_get_device_side_mangled_name, "cC*.", "ncT", CUDA_LANG)
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -8232,6 +8232,9 @@ def err_atomic_op_needs_non_const_pointer : Error<
 def err_atomic_op_needs_trivial_copy : Error<
   "address argument to atomic operation must be a pointer to a "
   "trivially-copyable type (%0 invalid)">;
+def err_atomic_op_needs_atomic_int_ptr_or_fp : Error<
+  "address argument to atomic operation must be a pointer to %select{|atomic }0"
+  "integer, pointer or supported floating point type (%1 invalid)">;
 def err_atomic_op_needs_atomic_int_or_ptr : Error<
   "address argument to atomic operation must be a pointer to %select{|atomic }0"
   "integer or pointer (%1 invalid)">;

clang/include/clang/Index/DeclOccurrence.h

@@ -9,26 +9,31 @@
 #ifndef LLVM_CLANG_INDEX_DECLOCCURRENCE_H
 #define LLVM_CLANG_INDEX_DECLOCCURRENCE_H
 
+#include "clang/AST/DeclBase.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Index/IndexSymbol.h"
+#include "clang/Lex/MacroInfo.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace clang {
-class Decl;
-
 namespace index {
 
 struct DeclOccurrence {
   SymbolRoleSet Roles;
   unsigned Offset;
-  const Decl *Dcl;
+  llvm::PointerUnion<const Decl *, const MacroInfo *> DeclOrMacro;
+  const IdentifierInfo *MacroName = nullptr;
   SmallVector<SymbolRelation, 3> Relations;
 
   DeclOccurrence(SymbolRoleSet R, unsigned Offset, const Decl *D,
                  ArrayRef<SymbolRelation> Relations)
-      : Roles(R), Offset(Offset), Dcl(D),
+      : Roles(R), Offset(Offset), DeclOrMacro(D),
         Relations(Relations.begin(), Relations.end()) {}
+  DeclOccurrence(SymbolRoleSet R, unsigned Offset, const IdentifierInfo *Name,
+                 const MacroInfo *MI)
+      : Roles(R), Offset(Offset), DeclOrMacro(MI), MacroName(Name) {}
 
   friend bool operator<(const DeclOccurrence &LHS, const DeclOccurrence &RHS) {
     return LHS.Offset < RHS.Offset;